@developer.k/ms-office-mcp 1.0.0

package/build/tools/ppt.js

@@ -0,0 +1,521 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { runPowerShell, textContent, toBase64 } from "../office-utils.js";
+const require = createRequire(import.meta.url);
+const PptxGenJS = require("pptxgenjs");
+const officeParser = require("officeparser");
+const ReadPptSchema = z.object({
+    path: z.string().describe("Path to the PowerPoint file (.pptx)"),
+});
+const WritePptSchema = z.object({
+    path: z.string().describe("Path to the PowerPoint file (.pptx)"),
+    slides: z.array(z.object({
+        title: z.string().optional().describe("Slide title"),
+        content: z.string().describe("Slide text content"),
+    })).describe("Array of slides with title and content"),
+});
+const GetActiveOfficeSchema = z.object({
+    filename: z.string().optional().describe("Name of the specific file to get data from. If omitted, the active document is used."),
+});
+const WriteActivePptSchema = z.object({
+    filename: z.string().optional().describe("Name of the presentation. If omitted, the active presentation is used."),
+    operation: z.enum(["add_slide", "replace_text", "replace_slide_text"]).describe("How to edit the active PowerPoint presentation"),
+    slideIndex: z.number().int().positive().optional().describe("1-based slide index for slide-scoped operations"),
+    title: z.string().optional().describe("Slide title when adding a slide"),
+    text: z.string().describe("Text to insert or use as replacement content"),
+    findText: z.string().optional().describe("Text to find when operation is replace_text"),
+    replaceAllMatches: z.boolean().optional().default(false).describe("Replace every match instead of only the first match"),
+});
+const InspectActivePptSchema = z.object({
+    filename: z.string().optional().describe("Name of the presentation. If omitted, the active presentation is used."),
+    slideIndex: z.number().int().positive().optional().describe("1-based slide index to inspect. If omitted, all slides are inspected."),
+});
+const EditActivePptObjectSchema = z.object({
+    filename: z.string().optional().describe("Name of the presentation. If omitted, the active presentation is used."),
+    slideIndex: z.number().int().positive().describe("1-based slide index containing the target shape"),
+    shapeId: z.number().int().positive().optional().describe("PowerPoint shape ID from inspect_active_pptx"),
+    shapeName: z.string().optional().describe("PowerPoint shape name from inspect_active_pptx"),
+    operation: z.enum(["set_text", "set_position", "set_size", "set_fill_color", "set_line_color", "delete"]).describe("Object edit operation"),
+    text: z.string().optional().describe("Text to set when operation is set_text"),
+    left: z.number().optional().describe("Left position in points when operation is set_position"),
+    top: z.number().optional().describe("Top position in points when operation is set_position"),
+    width: z.number().positive().optional().describe("Width in points when operation is set_size"),
+    height: z.number().positive().optional().describe("Height in points when operation is set_size"),
+    color: z.string().optional().describe("RGB hex color such as #FFAA00 or FFAA00 for color operations"),
+});
+export const pptTools = {
+    tools: [
+        {
+            name: "read_pptx",
+            description: "Read text content from a PowerPoint file (.pptx)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Path to the PowerPoint file" },
+                },
+                required: ["path"],
+            },
+        },
+        {
+            name: "write_pptx",
+            description: "Create a new PowerPoint file with slides",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Path to the PowerPoint file" },
+                    slides: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                title: { type: "string", description: "Slide title (optional)" },
+                                content: { type: "string", description: "Slide content" },
+                            },
+                            required: ["content"],
+                        },
+                        description: "Array of slides",
+                    },
+                },
+                required: ["path", "slides"],
+            },
+        },
+        {
+            name: "list_active_pptx",
+            description: "List all open PowerPoint presentations",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "get_active_pptx",
+            description: "Get slide text from a currently open (active) PowerPoint presentation without saving",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filename: { type: "string", description: "Name of the presentation (e.g., 'Presentation1.pptx'). If omitted, the active presentation is used." },
+                },
+            },
+        },
+        {
+            name: "write_active_pptx",
+            description: "Edit a currently open PowerPoint presentation without saving. Supports add_slide, replace_text, and replace_slide_text.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filename: { type: "string", description: "Name of the presentation (e.g., 'Presentation1.pptx'). If omitted, the active presentation is used." },
+                    operation: {
+                        type: "string",
+                        enum: ["add_slide", "replace_text", "replace_slide_text"],
+                        description: "add_slide creates a new slide, replace_text replaces matching text in shapes, replace_slide_text rewrites one slide's text boxes",
+                    },
+                    slideIndex: { type: "number", description: "1-based slide index for slide-scoped operations" },
+                    title: { type: "string", description: "Slide title when adding a slide" },
+                    text: { type: "string", description: "Text to insert or use as replacement content" },
+                    findText: { type: "string", description: "Text to find when operation is replace_text" },
+                    replaceAllMatches: { type: "boolean", description: "Replace every match instead of only the first match" },
+                },
+                required: ["operation", "text"],
+            },
+        },
+        {
+            name: "inspect_active_pptx",
+            description: "Inspect slides and shapes in a currently open PowerPoint presentation. Returns shape IDs, names, types, positions, sizes, text, and basic styling.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filename: { type: "string", description: "Name of the presentation (e.g., 'Presentation1.pptx'). If omitted, the active presentation is used." },
+                    slideIndex: { type: "number", description: "1-based slide index to inspect. If omitted, all slides are inspected." },
+                },
+            },
+        },
+        {
+            name: "edit_active_pptx_object",
+            description: "Edit a non-selected PowerPoint shape by slideIndex and shapeId or shapeName. Supports text, position, size, fill color, line color, and delete.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    filename: { type: "string", description: "Name of the presentation (e.g., 'Presentation1.pptx'). If omitted, the active presentation is used." },
+                    slideIndex: { type: "number", description: "1-based slide index containing the target shape" },
+                    shapeId: { type: "number", description: "Shape ID from inspect_active_pptx" },
+                    shapeName: { type: "string", description: "Shape name from inspect_active_pptx" },
+                    operation: {
+                        type: "string",
+                        enum: ["set_text", "set_position", "set_size", "set_fill_color", "set_line_color", "delete"],
+                        description: "Object edit operation",
+                    },
+                    text: { type: "string", description: "Text to set when operation is set_text" },
+                    left: { type: "number", description: "Left position in points when operation is set_position" },
+                    top: { type: "number", description: "Top position in points when operation is set_position" },
+                    width: { type: "number", description: "Width in points when operation is set_size" },
+                    height: { type: "number", description: "Height in points when operation is set_size" },
+                    color: { type: "string", description: "RGB hex color such as #FFAA00 or FFAA00 for color operations" },
+                },
+                required: ["slideIndex", "operation"],
+            },
+        },
+    ],
+    handlers: {
+        async read_pptx(args) {
+            const { path: filePath } = ReadPptSchema.parse(args);
+            const absolutePath = path.resolve(filePath);
+            if (!fs.existsSync(absolutePath)) {
+                throw new McpError(ErrorCode.InvalidParams, `File not found: ${filePath}`);
+            }
+            const result = await new Promise((resolve, reject) => {
+                officeParser.parseOffice(absolutePath, (data, err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(data);
+                });
+            });
+            const text = typeof result === "string" ? result : (result.toText ? result.toText() : JSON.stringify(result));
+            return textContent(text);
+        },
+        async write_pptx(args) {
+            const { path: filePath, slides } = WritePptSchema.parse(args);
+            const absolutePath = path.resolve(filePath);
+            const pres = new PptxGenJS();
+            slides.forEach(slideData => {
+                const slide = pres.addSlide();
+                if (slideData.title) {
+                    slide.addText(slideData.title, {
+                        x: 0.5, y: 0.5, fontSize: 24, bold: true,
+                        fontFace: "Malgun Gothic",
+                    });
+                }
+                slide.addText(slideData.content, {
+                    x: 0.5, y: 1.5, fontSize: 18,
+                    fontFace: "Malgun Gothic",
+                });
+            });
+            await pres.writeFile({ fileName: absolutePath });
+            return textContent(`Successfully created PowerPoint file at ${filePath}`);
+        },
+        async list_active_pptx() {
+            const script = `
+        $ppt = [Runtime.InteropServices.Marshal]::GetActiveObject('PowerPoint.Application')
+        $names = @($ppt.Presentations | ForEach-Object { $_.Name })
+        ConvertTo-Json -InputObject @($names) -Compress
+      `;
+            return textContent(runPowerShell(script));
+        },
+        async get_active_pptx(args) {
+            const { filename } = GetActiveOfficeSchema.parse(args);
+            const script = `
+        $ppt = [Runtime.InteropServices.Marshal]::GetActiveObject('PowerPoint.Application')
+        $target = "${filename || ""}"
+        $pres = if ($target) {
+            $ppt.Presentations | Where-Object { $_.Name -eq $target -or $_.FullName -eq $target } | Select-Object -First 1
+        } else {
+            $ppt.ActivePresentation
+        }
+        if ($null -eq $pres) { throw "Presentation '$target' not found or no active presentation." }
+        $slides = foreach ($slide in $pres.Slides) {
+            $text = ""
+            foreach ($shape in $slide.Shapes) {
+                if ($shape.HasTextFrame -and $shape.TextFrame.HasText) {
+                    $text += $shape.TextFrame.TextRange.Text + "\`n"
+                }
+            }
+            @{ Index = $slide.SlideIndex; Content = $text.Trim() }
+        }
+        ConvertTo-Json -InputObject @($slides) -Compress
+      `;
+            return textContent(runPowerShell(script));
+        },
+        async write_active_pptx(args) {
+            const { filename, operation, slideIndex, title, text, findText, replaceAllMatches } = WriteActivePptSchema.parse(args);
+            if (operation === "replace_text" && !findText) {
+                throw new McpError(ErrorCode.InvalidParams, "findText is required when operation is replace_text.");
+            }
+            if (operation === "replace_slide_text" && !slideIndex) {
+                throw new McpError(ErrorCode.InvalidParams, "slideIndex is required when operation is replace_slide_text.");
+            }
+            const filenameBase64 = toBase64(filename || "");
+            const titleBase64 = toBase64(title || "");
+            const textBase64 = toBase64(text);
+            const findTextBase64 = toBase64(findText || "");
+            const script = `
+        function Decode-Utf8([string]$value) {
+          [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($value))
+        }
+
+        function Replace-FirstLiteral([string]$source, [string]$find, [string]$replacement) {
+          $index = $source.IndexOf($find, [System.StringComparison]::Ordinal)
+          if ($index -lt 0) { return @{ Text = $source; Changed = $false } }
+          $before = $source.Substring(0, $index)
+          $after = $source.Substring($index + $find.Length)
+          return @{ Text = $before + $replacement + $after; Changed = $true }
+        }
+
+        $ppt = [Runtime.InteropServices.Marshal]::GetActiveObject('PowerPoint.Application')
+        $target = Decode-Utf8 '${filenameBase64}'
+        $operation = '${operation}'
+        $slideIndex = ${slideIndex || 0}
+        $title = Decode-Utf8 '${titleBase64}'
+        $text = Decode-Utf8 '${textBase64}'
+        $findText = Decode-Utf8 '${findTextBase64}'
+        $replaceAllMatches = [System.Convert]::ToBoolean('${replaceAllMatches}')
+
+        $pres = if ($target) {
+            $ppt.Presentations | Where-Object { $_.Name -eq $target -or $_.FullName -eq $target } | Select-Object -First 1
+        } else {
+            $ppt.ActivePresentation
+        }
+        if ($null -eq $pres) { throw "Presentation '$target' not found or no active presentation." }
+
+        if ($operation -eq 'add_slide') {
+            $slide = $pres.Slides.Add($pres.Slides.Count + 1, 12)
+            if ($title) {
+                $titleBox = $slide.Shapes.AddTextbox(1, 36, 36, 648, 54)
+                $titleBox.TextFrame.TextRange.Text = $title
+                $titleBox.TextFrame.TextRange.Font.Size = 28
+                $titleBox.TextFrame.TextRange.Font.Bold = $true
+            }
+            $bodyBox = $slide.Shapes.AddTextbox(1, 36, 108, 648, 360)
+            $bodyBox.TextFrame.TextRange.Text = $text
+            $bodyBox.TextFrame.TextRange.Font.Size = 18
+            $result = @{ Presentation = $pres.Name; Operation = $operation; SlideIndex = $slide.SlideIndex; Changed = 1 }
+        } elseif ($operation -eq 'replace_slide_text') {
+            if ($slideIndex -lt 1 -or $slideIndex -gt $pres.Slides.Count) { throw "Slide index $slideIndex is out of range." }
+            $slide = $pres.Slides.Item($slideIndex)
+            $changed = 0
+            $textShapes = @()
+            foreach ($shape in $slide.Shapes) {
+                if ($shape.HasTextFrame -and $shape.TextFrame.HasText) {
+                    $textShapes += $shape
+                }
+            }
+            if ($textShapes.Count -eq 0) {
+                $bodyBox = $slide.Shapes.AddTextbox(1, 36, 108, 648, 360)
+                $bodyBox.TextFrame.TextRange.Text = $text
+                $changed = 1
+            } else {
+                $textShapes[0].TextFrame.TextRange.Text = $text
+                for ($i = 1; $i -lt $textShapes.Count; $i++) {
+                    $textShapes[$i].TextFrame.TextRange.Text = ""
+                }
+                $changed = 1
+            }
+            $result = @{ Presentation = $pres.Name; Operation = $operation; SlideIndex = $slideIndex; Changed = $changed }
+        } elseif ($operation -eq 'replace_text') {
+            $changed = 0
+            $slides = if ($slideIndex -gt 0) {
+                if ($slideIndex -gt $pres.Slides.Count) { throw "Slide index $slideIndex is out of range." }
+                @($pres.Slides.Item($slideIndex))
+            } else {
+                @($pres.Slides | ForEach-Object { $_ })
+            }
+
+            foreach ($slide in $slides) {
+                foreach ($shape in $slide.Shapes) {
+                    if ($shape.HasTextFrame -and $shape.TextFrame.HasText) {
+                        $current = [string]$shape.TextFrame.TextRange.Text
+                        if ($replaceAllMatches) {
+                            $next = $current.Replace($findText, $text)
+                            if ($next -ne $current) {
+                                $shape.TextFrame.TextRange.Text = $next
+                                $changed++
+                            }
+                        } else {
+                            $replacement = Replace-FirstLiteral $current $findText $text
+                            if ($replacement.Changed) {
+                                $shape.TextFrame.TextRange.Text = $replacement.Text
+                                $changed++
+                                break
+                            }
+                        }
+                    }
+                }
+                if (-not $replaceAllMatches -and $changed -gt 0) { break }
+            }
+            $result = @{ Presentation = $pres.Name; Operation = $operation; SlideIndex = $slideIndex; Changed = $changed; ReplacedAllMatches = $replaceAllMatches }
+        } else {
+            throw "Unsupported PowerPoint operation: $operation"
+        }
+
+        ConvertTo-Json -InputObject $result -Compress
+      `;
+            return textContent(runPowerShell(script));
+        },
+        async inspect_active_pptx(args) {
+            const { filename, slideIndex } = InspectActivePptSchema.parse(args);
+            const filenameBase64 = toBase64(filename || "");
+            const script = `
+        function Decode-Utf8([string]$value) {
+          [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($value))
+        }
+
+        function Get-RgbHex($rgb) {
+          if ($null -eq $rgb -or $rgb -lt 0) { return $null }
+          $red = $rgb -band 255
+          $green = ($rgb -shr 8) -band 255
+          $blue = ($rgb -shr 16) -band 255
+          return ('#{0:X2}{1:X2}{2:X2}' -f $red, $green, $blue)
+        }
+
+        $ppt = [Runtime.InteropServices.Marshal]::GetActiveObject('PowerPoint.Application')
+        $target = Decode-Utf8 '${filenameBase64}'
+        $slideIndex = ${slideIndex || 0}
+        $pres = if ($target) {
+            $ppt.Presentations | Where-Object { $_.Name -eq $target -or $_.FullName -eq $target } | Select-Object -First 1
+        } else {
+            $ppt.ActivePresentation
+        }
+        if ($null -eq $pres) { throw "Presentation '$target' not found or no active presentation." }
+
+        $slides = if ($slideIndex -gt 0) {
+            if ($slideIndex -gt $pres.Slides.Count) { throw "Slide index $slideIndex is out of range." }
+            @($pres.Slides.Item($slideIndex))
+        } else {
+            @($pres.Slides | ForEach-Object { $_ })
+        }
+
+        $resultSlides = foreach ($slide in $slides) {
+            $shapes = foreach ($shape in $slide.Shapes) {
+                $text = $null
+                if ($shape.HasTextFrame -and $shape.TextFrame.HasText) {
+                    $text = [string]$shape.TextFrame.TextRange.Text
+                }
+
+                $fillColor = $null
+                $lineColor = $null
+                try {
+                    if ($shape.Fill.Visible) { $fillColor = Get-RgbHex $shape.Fill.ForeColor.RGB }
+                } catch {}
+                try {
+                    if ($shape.Line.Visible) { $lineColor = Get-RgbHex $shape.Line.ForeColor.RGB }
+                } catch {}
+
+                @{
+                    Id = $shape.Id
+                    Name = $shape.Name
+                    Type = $shape.Type
+                    AutoShapeType = $shape.AutoShapeType
+                    Left = [math]::Round($shape.Left, 2)
+                    Top = [math]::Round($shape.Top, 2)
+                    Width = [math]::Round($shape.Width, 2)
+                    Height = [math]::Round($shape.Height, 2)
+                    HasText = [bool]($shape.HasTextFrame -and $shape.TextFrame.HasText)
+                    Text = $text
+                    FillColor = $fillColor
+                    LineColor = $lineColor
+                }
+            }
+
+            @{
+                Index = $slide.SlideIndex
+                Name = $slide.Name
+                Width = [math]::Round($pres.PageSetup.SlideWidth, 2)
+                Height = [math]::Round($pres.PageSetup.SlideHeight, 2)
+                Shapes = @($shapes)
+            }
+        }
+
+        ConvertTo-Json -InputObject @{ Presentation = $pres.Name; Slides = @($resultSlides) } -Depth 6 -Compress
+      `;
+            return textContent(runPowerShell(script));
+        },
+        async edit_active_pptx_object(args) {
+            const { filename, slideIndex, shapeId, shapeName, operation, text, left, top, width, height, color } = EditActivePptObjectSchema.parse(args);
+            if (!shapeId && !shapeName) {
+                throw new McpError(ErrorCode.InvalidParams, "shapeId or shapeName is required.");
+            }
+            if (operation === "set_text" && text === undefined) {
+                throw new McpError(ErrorCode.InvalidParams, "text is required when operation is set_text.");
+            }
+            if (operation === "set_position" && (left === undefined || top === undefined)) {
+                throw new McpError(ErrorCode.InvalidParams, "left and top are required when operation is set_position.");
+            }
+            if (operation === "set_size" && (width === undefined || height === undefined)) {
+                throw new McpError(ErrorCode.InvalidParams, "width and height are required when operation is set_size.");
+            }
+            if ((operation === "set_fill_color" || operation === "set_line_color") && !color) {
+                throw new McpError(ErrorCode.InvalidParams, "color is required for color operations.");
+            }
+            const normalizedColor = color ? color.replace(/^#/, "") : "";
+            if (normalizedColor && !/^[0-9a-fA-F]{6}$/.test(normalizedColor)) {
+                throw new McpError(ErrorCode.InvalidParams, "color must be a 6-digit RGB hex value, such as #FFAA00.");
+            }
+            const filenameBase64 = toBase64(filename || "");
+            const shapeNameBase64 = toBase64(shapeName || "");
+            const textBase64 = toBase64(text || "");
+            const script = `
+        function Decode-Utf8([string]$value) {
+          [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($value))
+        }
+
+        function Convert-HexToOfficeRgb([string]$hex) {
+          if (-not $hex) { return 0 }
+          $red = [Convert]::ToInt32($hex.Substring(0, 2), 16)
+          $green = [Convert]::ToInt32($hex.Substring(2, 2), 16)
+          $blue = [Convert]::ToInt32($hex.Substring(4, 2), 16)
+          return $red + ($green -shl 8) + ($blue -shl 16)
+        }
+
+        $ppt = [Runtime.InteropServices.Marshal]::GetActiveObject('PowerPoint.Application')
+        $target = Decode-Utf8 '${filenameBase64}'
+        $slideIndex = ${slideIndex}
+        $shapeId = ${shapeId || 0}
+        $shapeName = Decode-Utf8 '${shapeNameBase64}'
+        $operation = '${operation}'
+        $text = Decode-Utf8 '${textBase64}'
+        $left = ${left ?? 0}
+        $top = ${top ?? 0}
+        $width = ${width ?? 0}
+        $height = ${height ?? 0}
+        $color = '${normalizedColor}'
+
+        $pres = if ($target) {
+            $ppt.Presentations | Where-Object { $_.Name -eq $target -or $_.FullName -eq $target } | Select-Object -First 1
+        } else {
+            $ppt.ActivePresentation
+        }
+        if ($null -eq $pres) { throw "Presentation '$target' not found or no active presentation." }
+        if ($slideIndex -gt $pres.Slides.Count) { throw "Slide index $slideIndex is out of range." }
+
+        $slide = $pres.Slides.Item($slideIndex)
+        $targetShape = $null
+        foreach ($shape in $slide.Shapes) {
+            if (($shapeId -gt 0 -and $shape.Id -eq $shapeId) -or ($shapeName -and $shape.Name -eq $shapeName)) {
+                $targetShape = $shape
+                break
+            }
+        }
+        if ($null -eq $targetShape) { throw "Shape not found on slide $slideIndex." }
+
+        $shapeInfo = @{ Id = $targetShape.Id; Name = $targetShape.Name; SlideIndex = $slideIndex }
+
+        if ($operation -eq 'set_text') {
+            if (-not $targetShape.HasTextFrame) { throw "Target shape does not support text." }
+            $targetShape.TextFrame.TextRange.Text = $text
+        } elseif ($operation -eq 'set_position') {
+            $targetShape.Left = $left
+            $targetShape.Top = $top
+        } elseif ($operation -eq 'set_size') {
+            $targetShape.Width = $width
+            $targetShape.Height = $height
+        } elseif ($operation -eq 'set_fill_color') {
+            $targetShape.Fill.Visible = $true
+            $targetShape.Fill.ForeColor.RGB = Convert-HexToOfficeRgb $color
+        } elseif ($operation -eq 'set_line_color') {
+            $targetShape.Line.Visible = $true
+            $targetShape.Line.ForeColor.RGB = Convert-HexToOfficeRgb $color
+        } elseif ($operation -eq 'delete') {
+            $targetShape.Delete()
+        } else {
+            throw "Unsupported object operation: $operation"
+        }
+
+        $result = @{ Presentation = $pres.Name; Operation = $operation; Changed = 1; Shape = $shapeInfo }
+        ConvertTo-Json -InputObject $result -Depth 4 -Compress
+      `;
+            return textContent(runPowerShell(script));
+        },
+    },
+};