glosc-mcp 1.1.1 → 1.2.1

package/README.md

@@ -16,23 +16,34 @@
   }
 }
 ```
-
 ### Tools
 
 - `listApps`
-	- 获取已安装应用列表（Windows 注册表）
 	- 入参：`{ query?: string, matchMode?: "contains"|"equals"|"regex", limit?: number }`
 
 - `getAppInstallPath`
 	- 获取应用安装路径（优先 `InstallLocation`，否则从 `DisplayIcon`/卸载命令推断）
 	- 入参：`{ name: string, matchMode?: "contains"|"equals"|"regex", allMatches?: boolean, limit?: number }`
-
 - `openRef`
 	- 打开引用（文件/文件夹/URL/可执行文件），使用系统默认方式打开（Windows 下使用 `Start-Process`）
 	- 入参：`{ target: string, args?: string[], wait?: boolean }`
 
+- `readFile`
+	- 读取文件内容，支持多种文件类型：文本、图片、表格、文档、压缩包（ZIP、RAR、7Z、TAR、GZ等）
+	- 入参：`{ path: string }`
+	- 说明：读取 Excel（.xlsx/.xls）时，若只有 1 张表则返回该表的行数组 JSON；若有多张表则返回 `{ sheets: [{ sheetName, rows }] }`。
 - `editText`
   - 文本写入/编辑：按行添加/替换/删除（可批量），或创建/替换/删除整个文件
   - 入参（概要）：
-    - 整文件：`{ path, file: { action: "create"|"replace"|"delete", content?, overwrite? }, encoding?, newline?, ensureFinalNewline?, returnContent? }`
-    - 按行：`{ path, edits: [{ op: "add"|"replace"|"delete", ... }], createIfMissing?, encoding?, newline?, ensureFinalNewline?, returnContent? }`
+    - 按行：`{ path, edits: [{ op: "add"|"replace"|"delete", ... }], createIfMissing?, encoding?, newline?, ensureFinalNewline?, returnContent? }`
+- `renameFile`
+  - 重命名文件（同目录改名）
+  - 入参：`{ path: string, newName: string, overwrite?: boolean }`
+
+- `moveFile`
+  - 移动文件到新路径（必要时自动创建目录；目标为目录时会移动到该目录下）
+  - 入参：`{ from: string, to: string, overwrite?: boolean, createDirs?: boolean }`
+
+- `listFilesRecursive`
+  - 递归获取文件夹中的所有文件（默认最多返回 5000 条，避免输出过大）
+  - 入参：`{ dir: string, limit?: number }`

package/build/GloscMcp.js

@@ -178,122 +178,106 @@ export class GloscMcp {
                 ],
             };
         });
-        this.server.registerTool("editText", {
-            description: "文本写入/编辑：支持按行添加/替换/删除（可批量），或创建/替换/删除整个文件",
-            inputSchema: z
-                .object({
-                path: z.string().describe("文件的绝对路径"),
-                encoding: z
+        this.server.registerTool("renameFile", {
+            description: "重命名文件（同目录改名）",
+            inputSchema: z.object({
+                path: z.string().describe("源文件的绝对路径"),
+                newName: z
                     .string()
-                    .describe("文本编码（默认 utf8）")
-                    .default("utf8"),
-                newline: z
-                    .enum(["auto", "lf", "crlf"])
-                    .describe("换行符策略：auto/lf/crlf")
-                    .default("auto"),
-                ensureFinalNewline: z
+                    .describe("新文件名（仅文件名，不含路径）"),
+                overwrite: z
                     .boolean()
-                    .describe("是否确保文件末尾以换行结尾")
+                    .describe("目标已存在时是否覆盖")
                     .default(false),
-                returnContent: z
+            }),
+        }, async ({ path, newName, overwrite }) => {
+            try {
+                const res = await GloscTools.renameFile({
+                    path,
+                    newName,
+                    overwrite,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `重命名失败: ${errorMessage}`,
+                        },
+                    ],
+                };
+            }
+        });
+        this.server.registerTool("moveFile", {
+            description: "移动文件到新路径（必要时自动创建目录）",
+            inputSchema: z.object({
+                from: z.string().describe("源文件的绝对路径"),
+                to: z.string().describe("目标路径（文件路径或目录）"),
+                overwrite: z
                     .boolean()
-                    .describe("是否在结果中返回最终内容（可能很大）")
+                    .describe("目标已存在时是否覆盖")
                     .default(false),
-                createIfMissing: z
+                createDirs: z
                     .boolean()
-                    .describe("按行 edits 时文件不存在是否自动新建（默认 false）")
-                    .default(false),
-                file: z
-                    .union([
-                    z.object({
-                        action: z
-                            .literal("create")
-                            .describe("新建文件"),
-                        content: z.string().describe("文件内容"),
-                        overwrite: z
-                            .boolean()
-                            .describe("文件已存在时是否覆盖")
-                            .default(false),
-                    }),
-                    z.object({
-                        action: z
-                            .literal("replace")
-                            .describe("替换整个文件内容"),
-                        content: z.string().describe("文件内容"),
-                    }),
-                    z.object({
-                        action: z
-                            .literal("delete")
-                            .describe("删除文件"),
-                    }),
-                ])
-                    .optional(),
-                edits: z
-                    .array(z.union([
-                    z.object({
-                        op: z.literal("add"),
-                        at: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .describe("插入位置行号（1-based）；允许 lineCount+1 表示追加"),
-                        position: z
-                            .enum(["before", "after"])
-                            .describe("插入到该行之前或之后")
-                            .default("before"),
-                        lines: z
-                            .array(z.string())
-                            .min(1)
-                            .describe("要插入的行（不含换行符）"),
-                    }),
-                    z.object({
-                        op: z.literal("replace"),
-                        start: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .describe("起始行号（1-based）"),
-                        end: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .optional()
-                            .describe("结束行号（1-based，含）；缺省则等于 start"),
-                        lines: z
-                            .array(z.string())
-                            .describe("替换后的行（可多行）"),
-                    }),
-                    z.object({
-                        op: z.literal("delete"),
-                        start: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .describe("起始行号（1-based）"),
-                        end: z
-                            .number()
-                            .int()
-                            .min(1)
-                            .optional()
-                            .describe("结束行号（1-based，含）；缺省则等于 start"),
-                    }),
-                ]))
-                    .optional(),
-            })
-                .refine((v) => !!v.file !== !!v.edits, {
-                message: "必须且只能提供 file 或 edits 之一",
+                    .describe("是否自动创建目标目录")
+                    .default(true),
             }),
-        }, async (input) => {
+        }, async ({ from, to, overwrite, createDirs }) => {
+            try {
+                const res = await GloscTools.moveFile({
+                    from,
+                    to,
+                    overwrite,
+                    createDirs,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `移动失败: ${errorMessage}`,
+                        },
+                    ],
+                };
+            }
+        });
+        this.server.registerTool("listFilesRecursive", {
+            description: "递归获取文件夹中的所有文件",
+            inputSchema: z.object({
+                dir: z.string().describe("目录的绝对路径"),
+                limit: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(20000)
+                    .describe("最多返回多少条（防止输出过大）")
+                    .default(5000),
+            }),
+        }, async ({ dir, limit }) => {
             try {
-                const res = await GloscTools.editTextFile({
-                    path: input.path,
-                    encoding: input.encoding,
-                    newline: input.newline,
-                    ensureFinalNewline: input.ensureFinalNewline,
-                    returnContent: input.returnContent,
-                    createIfMissing: input.createIfMissing,
-                    file: input.file,
-                    edits: input.edits,
+                const res = await GloscTools.listFilesRecursive({
+                    dir,
+                    limit,
                 });
                 return {
                     content: [
@@ -310,7 +294,7 @@ export class GloscMcp {
                     content: [
                         {
                             type: "text",
-                            text: `编辑文本失败: ${errorMessage}`,
+                            text: `列出文件失败: ${errorMessage}`,
                         },
                     ],
                 };

package/build/GloscTools.js

@@ -449,10 +449,28 @@ if ($null -ne $apps) {
         else if ([".xlsx", ".xls"].includes(ext)) {
             // Excel文件，解析为JSON
             const workbook = XLSX.read(buffer, { type: "buffer" });
-            const sheetName = workbook.SheetNames[0];
-            const worksheet = workbook.Sheets[sheetName];
-            const json = XLSX.utils.sheet_to_json(worksheet);
-            return JSON.stringify(json, null, 2);
+            const sheetNames = (workbook.SheetNames ?? []).filter((name) => typeof name === "string" && name.trim().length > 0);
+            if (sheetNames.length === 0) {
+                return JSON.stringify([], null, 2);
+            }
+            const sheets = sheetNames.map((sheetName) => {
+                const worksheet = workbook.Sheets[sheetName];
+                const rows = worksheet
+                    ? XLSX.utils.sheet_to_json(worksheet, {
+                        defval: null,
+                    })
+                    : [];
+                return {
+                    sheetName,
+                    rows,
+                };
+            });
+            // 兼容：只有 1 张表时保持旧行为（直接返回行数组）
+            if (sheets.length === 1) {
+                return JSON.stringify(sheets[0].rows, null, 2);
+            }
+            // 多张表：返回按 sheet 分组的结构，避免数据混淆
+            return JSON.stringify({ sheets }, null, 2);
         }
         else if (ext === ".pdf") {
             // PDF文件，提取文本
@@ -508,184 +526,154 @@ if ($null -ne $apps) {
         // 支持 \n / \r\n，且保留末尾空行（比如文件以换行结尾）
         if (text === "")
             return [""];
-        const lines = text.split(/\r?\n/);
-        return lines;
+        return text.split(/\r?\n/);
     }
     static joinLines(lines, newline) {
         return lines.join(newline);
     }
-    static async editTextFile(options) {
-        const filePath = options.path?.trim();
-        if (!filePath)
-            throw new Error("path 不能为空");
-        const encoding = options.encoding ?? "utf8";
-        const returnContent = options.returnContent ?? false;
-        const createIfMissing = options.createIfMissing ?? false;
-        const hasFileAction = !!options.file;
-        const hasEdits = Array.isArray(options.edits) && options.edits.length > 0;
-        if ((hasFileAction && hasEdits) || (!hasFileAction && !hasEdits)) {
-            throw new Error("必须且只能提供 file 或 edits 之一");
-        }
-        let existedBefore = true;
-        let originalBuffer = null;
+    static async pathExists(p) {
         try {
-            originalBuffer = await fs.readFile(filePath);
+            await fs.stat(p);
+            return true;
         }
         catch (e) {
+            if (e && (e.code === "ENOENT" || e.code === "ENOTDIR"))
+                return false;
+            throw e;
+        }
+    }
+    static async removePath(targetPath) {
+        const st = await fs.lstat(targetPath);
+        if (st.isDirectory()) {
+            await fs.rm(targetPath, { recursive: true, force: true });
+        }
+        else {
+            await fs.unlink(targetPath);
+        }
+    }
+    static async movePathInternal(options) {
+        const from = options.from?.trim();
+        const to = options.to?.trim();
+        if (!from)
+            throw new Error("from 不能为空");
+        if (!to)
+            throw new Error("to 不能为空");
+        const overwrite = options.overwrite ?? false;
+        const createDirs = options.createDirs ?? true;
+        const fromStat = await fs.lstat(from).catch((e) => {
             if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) {
-                existedBefore = false;
-                originalBuffer = null;
-            }
-            else {
-                throw e;
+                throw new Error("源路径不存在");
             }
+            throw e;
+        });
+        let dest = to;
+        const toLooksLikeDir = /[\\/]+$/.test(to);
+        if (toLooksLikeDir) {
+            dest = path.join(to, path.basename(from));
         }
-        if (options.file) {
-            const action = options.file.action;
-            if (action === "delete") {
-                if (existedBefore) {
-                    await fs.unlink(filePath);
+        else {
+            try {
+                const toStat = await fs.lstat(to);
+                if (toStat.isDirectory()) {
+                    dest = path.join(to, path.basename(from));
                 }
-                return {
-                    ok: true,
-                    path: filePath,
-                    action: "delete",
-                    existedBefore,
-                };
             }
-            if (action === "create") {
-                if (existedBefore && !options.file.overwrite) {
-                    throw new Error("文件已存在，action=create 且 overwrite=false");
-                }
-                await fs.mkdir(path.dirname(filePath), { recursive: true });
-                const newline = GloscTools.normalizeNewlineOption(options.newline, undefined);
-                let content = options.file.content ?? "";
-                if (options.ensureFinalNewline) {
-                    if (!content.endsWith("\n") && !content.endsWith("\r\n")) {
-                        content += newline;
-                    }
+            catch (e) {
+                if (!(e && (e.code === "ENOENT" || e.code === "ENOTDIR"))) {
+                    throw e;
                 }
-                const outBuffer = iconv.encode(content, encoding);
-                await fs.writeFile(filePath, outBuffer);
-                return {
-                    ok: true,
-                    path: filePath,
-                    action: existedBefore ? "replace" : "create",
-                    existedBefore,
-                    bytesWritten: outBuffer.length,
-                    content: returnContent ? content : undefined,
-                };
             }
-            // replace
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            const decodedExisting = originalBuffer != null
-                ? iconv.decode(originalBuffer, encoding)
-                : undefined;
-            const newline = GloscTools.normalizeNewlineOption(options.newline, decodedExisting);
-            let content = options.file.content ?? "";
-            if (options.ensureFinalNewline) {
-                if (!content.endsWith("\n") && !content.endsWith("\r\n")) {
-                    content += newline;
-                }
+        }
+        if (await GloscTools.pathExists(dest)) {
+            if (!overwrite) {
+                throw new Error("目标已存在；如需覆盖请设置 overwrite=true");
             }
-            const outBuffer = iconv.encode(content, encoding);
-            await fs.writeFile(filePath, outBuffer);
-            return {
-                ok: true,
-                path: filePath,
-                action: "replace",
-                existedBefore,
-                bytesWritten: outBuffer.length,
-                content: returnContent ? content : undefined,
-            };
+            await GloscTools.removePath(dest);
         }
-        // line edits
-        let text = "";
-        if (originalBuffer != null) {
-            text = iconv.decode(originalBuffer, encoding);
+        if (createDirs) {
+            await fs.mkdir(path.dirname(dest), { recursive: true });
         }
-        else {
-            if (!createIfMissing) {
-                throw new Error("文件不存在；如需新建请使用 file.action=create 或 createIfMissing=true");
-            }
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
-            text = "";
-        }
-        const newline = GloscTools.normalizeNewlineOption(options.newline, text);
-        // 注意：split 后如果原文为空，返回 [""]，这样 lineCount 语义更贴近编辑器
-        let lines = GloscTools.splitLinesPreserveEmptyEnd(text);
-        const lineCountBefore = lines.length;
-        const edits = options.edits ?? [];
-        for (const edit of edits) {
-            if (edit.op === "add") {
-                const position = edit.position ?? "before";
-                const at = Math.trunc(edit.at);
-                if (!Number.isFinite(at) || at < 1) {
-                    throw new Error("add.at 必须为 >=1 的整数");
-                }
-                // 允许 at = lines.length + 1（before）用于追加到末尾
-                const maxAt = lines.length + 1;
-                if (at > maxAt) {
-                    throw new Error(`add.at 超出范围：当前最大允许 ${maxAt}（可用 lineCount+1 追加）`);
+        try {
+            await fs.rename(from, dest);
+            return { ok: true, from, to: dest };
+        }
+        catch (e) {
+            // 跨盘符/设备移动在部分平台会抛 EXDEV
+            if (e && e.code === "EXDEV") {
+                if (fromStat.isDirectory()) {
+                    const cp = fs.cp;
+                    if (!cp) {
+                        throw new Error("跨设备移动目录失败（EXDEV），且当前 Node 版本不支持 fs.cp");
+                    }
+                    await cp(from, dest, { recursive: true, force: overwrite });
+                    await fs.rm(from, { recursive: true, force: true });
+                    return { ok: true, from, to: dest };
                 }
-                const insertIndex = position === "after"
-                    ? Math.min(at, lines.length) // after 最多插在最后一行之后
-                    : at - 1;
-                lines.splice(insertIndex, 0, ...edit.lines);
+                await fs.copyFile(from, dest);
+                await fs.unlink(from);
+                return { ok: true, from, to: dest };
             }
-            else if (edit.op === "replace") {
-                const start = Math.trunc(edit.start);
-                const end = Math.trunc(edit.end ?? edit.start);
-                if (!Number.isFinite(start) || start < 1) {
-                    throw new Error("replace.start 必须为 >=1 的整数");
-                }
-                if (!Number.isFinite(end) || end < start) {
-                    throw new Error("replace.end 必须为 >= start 的整数");
-                }
-                if (end > lines.length) {
-                    throw new Error(`replace 超出范围：当前行数 ${lines.length}`);
-                }
-                lines.splice(start - 1, end - start + 1, ...edit.lines);
+            throw e;
+        }
+    }
+    static async renameFile(options) {
+        const from = options.path?.trim();
+        const newName = options.newName?.trim();
+        if (!from)
+            throw new Error("path 不能为空");
+        if (!newName)
+            throw new Error("newName 不能为空");
+        // 限制为“同目录改名”，避免把 rename 当 move 用
+        const base = path.basename(newName);
+        if (base !== newName) {
+            throw new Error("newName 只能是文件名，不能包含路径分隔符");
+        }
+        const to = path.join(path.dirname(from), newName);
+        return GloscTools.movePathInternal({
+            from,
+            to,
+            overwrite: options.overwrite,
+            createDirs: true,
+        });
+    }
+    static async moveFile(options) {
+        return GloscTools.movePathInternal(options);
+    }
+    static async listFilesRecursive(options) {
+        const dir = options.dir?.trim();
+        if (!dir)
+            throw new Error("dir 不能为空");
+        const limit = Math.max(1, Math.trunc(options.limit ?? 5000));
+        const rootStat = await fs.lstat(dir).catch((e) => {
+            if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) {
+                throw new Error("目录不存在");
             }
-            else if (edit.op === "delete") {
-                const start = Math.trunc(edit.start);
-                const end = Math.trunc(edit.end ?? edit.start);
-                if (!Number.isFinite(start) || start < 1) {
-                    throw new Error("delete.start 必须为 >=1 的整数");
-                }
-                if (!Number.isFinite(end) || end < start) {
-                    throw new Error("delete.end 必须为 >= start 的整数");
+            throw e;
+        });
+        if (!rootStat.isDirectory()) {
+            throw new Error("dir 必须是目录");
+        }
+        const files = [];
+        const stack = [dir];
+        let truncated = false;
+        while (stack.length > 0) {
+            const current = stack.pop();
+            const entries = await fs.readdir(current, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    stack.push(full);
                 }
-                if (end > lines.length) {
-                    throw new Error(`delete 超出范围：当前行数 ${lines.length}`);
+                else if (entry.isFile()) {
+                    files.push(full);
+                    if (files.length >= limit) {
+                        truncated = true;
+                        stack.length = 0;
+                        break;
+                    }
                 }
-                lines.splice(start - 1, end - start + 1);
-                if (lines.length === 0)
-                    lines = [""];
-            }
-            else {
-                const neverEdit = edit;
-                throw new Error(`未知 edit.op: ${neverEdit.op}`);
-            }
-        }
-        let outText = GloscTools.joinLines(lines, newline);
-        if (options.ensureFinalNewline) {
-            if (!outText.endsWith("\n") && !outText.endsWith("\r\n")) {
-                outText += newline;
             }
         }
-        const outBuffer = iconv.encode(outText, encoding);
-        await fs.writeFile(filePath, outBuffer);
-        return {
-            ok: true,
-            path: filePath,
-            action: "edit",
-            existedBefore,
-            lineCountBefore,
-            lineCountAfter: lines.length,
-            editsApplied: edits.length,
-            bytesWritten: outBuffer.length,
-            content: returnContent ? outText : undefined,
-        };
+        return { ok: true, dir, files, truncated };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glosc-mcp",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "main": "index.js",
   "type": "module",
   "bin": {