iwork-mcp 0.1.0

package/README.md

@@ -0,0 +1,165 @@
+# iwork-mcp
+
+MCP server that lets AI assistants create, read, edit, and export Apple iWork documents (Numbers, Pages, Keynote) through natural language.
+
+One line to install. Works with Claude Desktop and any MCP client.
+
+## What it does
+
+Ask Claude to build spreadsheets, write documents, and create presentations — and it controls the real iWork apps on your Mac through Apple's JavaScript for Automation (JXA) scripting bridge.
+
+**Numbers** — Create spreadsheets, read/write cells, set formulas, format ranges, add rows and columns, export to PDF/Excel/CSV.
+
+**Pages** — Create documents, read and append text, find and replace, format paragraphs, insert images and tables, export to PDF/Word/EPUB.
+
+**Keynote** — Create presentations, add slides, set titles and bullet points, add images and shapes, set transitions and presenter notes, start slideshows, export to PDF/PowerPoint/HTML.
+
+49 tools total.
+
+## Setup
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "iwork": {
+      "command": "npx",
+      "args": ["-y", "iwork-mcp"]
+    }
+  }
+}
+```
+
+Restart Claude Desktop. The tools will appear automatically.
+
+### Requirements
+
+- macOS (any version with iWork installed — it's free on every Mac)
+- Node.js 18+
+- On first use, macOS will prompt you to grant Automation permission
+
+## Examples
+
+> Create a new Numbers spreadsheet with columns Name, Age, and City. Add 5 rows of sample data and a SUM formula for the ages.
+
+> Open my budget spreadsheet at ~/Documents/budget.numbers and add a new row for February.
+
+> Create a Keynote presentation about renewable energy with 6 slides. Each slide should have a title and 3-4 bullet points.
+
+> Make a Pages document with a project proposal. Include a title, three sections with headers, and export it as a PDF to my Desktop.
+
+## Tools
+
+### Numbers (21 tools)
+
+| Tool | Description |
+|------|-------------|
+| `numbers_list_documents` | List all open documents |
+| `numbers_create_document` | Create a new spreadsheet |
+| `numbers_open_document` | Open a .numbers file |
+| `numbers_save_document` | Save a document |
+| `numbers_export_document` | Export to PDF, Excel, or CSV |
+| `numbers_close_document` | Close a document |
+| `numbers_list_sheets` | List sheets in a document |
+| `numbers_add_sheet` | Add a new sheet |
+| `numbers_list_tables` | List tables with dimensions |
+| `numbers_add_table` | Create a new table |
+| `numbers_read_table` | Read all data as a 2D array |
+| `numbers_read_cell` | Read a single cell |
+| `numbers_get_table_info` | Get table metadata |
+| `numbers_write_cell` | Write a value to a cell |
+| `numbers_write_cells` | Batch write multiple cells |
+| `numbers_set_formula` | Set a formula on a cell |
+| `numbers_add_row` | Add rows with optional data |
+| `numbers_add_column` | Add a column |
+| `numbers_format_cells` | Set font, size, color, alignment, background |
+| `numbers_set_column_width` | Set column width |
+| `numbers_set_row_height` | Set row height |
+
+### Pages (13 tools)
+
+| Tool | Description |
+|------|-------------|
+| `pages_list_documents` | List all open documents |
+| `pages_create_document` | Create a new document |
+| `pages_open_document` | Open a .pages file |
+| `pages_save_document` | Save a document |
+| `pages_export_document` | Export to PDF, Word, EPUB, or plain text |
+| `pages_close_document` | Close a document |
+| `pages_get_body_text` | Read all body text |
+| `pages_get_paragraphs` | Get paragraphs as indexed array |
+| `pages_add_text` | Append text to body |
+| `pages_replace_text` | Find and replace text |
+| `pages_format_text` | Set font, size, color, bold, italic on a paragraph |
+| `pages_add_image` | Insert an image |
+| `pages_add_table` | Insert a table |
+
+### Keynote (15 tools)
+
+| Tool | Description |
+|------|-------------|
+| `keynote_list_presentations` | List all open presentations |
+| `keynote_create_presentation` | Create a new presentation |
+| `keynote_open_presentation` | Open a .key file |
+| `keynote_save_presentation` | Save a presentation |
+| `keynote_export_presentation` | Export to PDF, PowerPoint, HTML, or images |
+| `keynote_close_presentation` | Close a presentation |
+| `keynote_list_slides` | List slides with titles |
+| `keynote_add_slide` | Add a slide with optional layout |
+| `keynote_set_slide_title` | Set slide title text |
+| `keynote_set_slide_body` | Set slide body / bullet points |
+| `keynote_add_image_to_slide` | Add an image to a slide |
+| `keynote_add_shape` | Add a shape with text |
+| `keynote_set_presenter_notes` | Set presenter notes |
+| `keynote_set_transition` | Set slide transition effect |
+| `keynote_start_slideshow` | Start playing the presentation |
+
+## How it works
+
+The server runs JXA (JavaScript for Automation) scripts via `osascript` to control iWork apps. Each tool call is a single `osascript` invocation that does all work internally — parameters go in as JSON via `argv[0]`, results come back as JSON via stdout.
+
+```
+Claude Desktop / Claude Code
+  ↓ MCP protocol over stdio
+iwork-mcp server (Node.js)
+  ↓ child_process.execFile
+/usr/bin/osascript -l JavaScript
+  ↓ JXA scripting bridge
+Numbers.app / Pages.app / Keynote.app
+```
+
+## Development
+
+```bash
+git clone https://github.com/nickarino/iwork-mcp.git
+cd iwork-mcp
+npm install
+npm run build
+```
+
+To test locally with Claude Desktop, point to your local build:
+
+```json
+{
+  "mcpServers": {
+    "iwork": {
+      "command": "node",
+      "args": ["/absolute/path/to/iwork-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+## Limitations
+
+- **macOS only** — requires iWork apps (Numbers, Pages, Keynote), which are free on every Mac
+- **Apps are visible** — iWork apps launch and show their windows; there's no headless mode
+- **~430ms per call** — osascript startup overhead on each tool invocation
+- **Formulas are write-only** — Apple's scripting dictionary returns computed values, not the formula text
+- **No comments or track changes** — not exposed in the scripting dictionary
+- **First-use permission prompt** — macOS will ask you to grant Automation access once
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerNumbersTools } from "./tools/numbers.js";
+import { registerPagesTools } from "./tools/pages.js";
+import { registerKeynoteTools } from "./tools/keynote.js";
+const server = new McpServer({
+    name: "iwork-mcp",
+    version: "0.1.0",
+});
+registerNumbersTools(server);
+registerPagesTools(server);
+registerKeynoteTools(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("iwork-mcp server running");

package/dist/jxa.d.ts

@@ -0,0 +1,17 @@
+export declare class OsascriptError extends Error {
+    readonly appleScriptErrorCode: number | undefined;
+    readonly stderr: string;
+    constructor(stderr: string, exitCode: number | null);
+}
+export interface RunJXAOptions {
+    timeout?: number;
+    maxBuffer?: number;
+}
+/**
+ * Execute a JXA (JavaScript for Automation) script via osascript.
+ *
+ * The script body is wrapped in `function run(argv) { ... }` automatically.
+ * If `params` is provided, it's JSON-serialized and passed as argv[0].
+ * The script should return a value; it will be JSON.stringify'd and parsed back.
+ */
+export declare function runJXA<T = unknown>(scriptBody: string, params?: Record<string, unknown>, options?: RunJXAOptions): Promise<T>;

package/dist/jxa.js

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+const COMMON_ERRORS = {
+    [-1743]: "Permission denied. Open System Settings → Privacy & Security → Automation and allow this app to control the iWork application.",
+    [-1728]: "Element not found. The specified document, sheet, table, or cell does not exist.",
+    [-128]: "User cancelled the operation.",
+    [-10810]: "The application is not running and could not be launched.",
+    [-1700]: "Invalid data type for the operation.",
+    [-1708]: "The application does not understand this command.",
+};
+export class OsascriptError extends Error {
+    appleScriptErrorCode;
+    stderr;
+    constructor(stderr, exitCode) {
+        const errorCode = parseErrorCode(stderr);
+        const friendly = errorCode !== undefined ? COMMON_ERRORS[errorCode] : undefined;
+        const message = friendly
+            ? `${friendly}\n\nosascript stderr: ${stderr}`
+            : `osascript failed (exit ${exitCode}): ${stderr}`;
+        super(message);
+        this.name = "OsascriptError";
+        this.appleScriptErrorCode = errorCode;
+        this.stderr = stderr;
+    }
+}
+function parseErrorCode(stderr) {
+    // JXA errors look like: "Error: Error: ... (-1743)"
+    // or "execution error: ... (-1728)"
+    const match = stderr.match(/\((-?\d+)\)\s*$/);
+    return match ? parseInt(match[1], 10) : undefined;
+}
+/**
+ * Execute a JXA (JavaScript for Automation) script via osascript.
+ *
+ * The script body is wrapped in `function run(argv) { ... }` automatically.
+ * If `params` is provided, it's JSON-serialized and passed as argv[0].
+ * The script should return a value; it will be JSON.stringify'd and parsed back.
+ */
+export function runJXA(scriptBody, params, options) {
+    const timeout = options?.timeout ?? 30_000;
+    const maxBuffer = options?.maxBuffer ?? 10 * 1024 * 1024;
+    // Wrap in run(argv) so osascript calls it with our args
+    const fullScript = `
+function run(argv) {
+  ${params !== undefined ? "const params = JSON.parse(argv[0]);" : ""}
+  ${scriptBody}
+}
+`;
+    const args = ["-l", "JavaScript", "-e", fullScript];
+    if (params !== undefined) {
+        args.push(JSON.stringify(params));
+    }
+    return new Promise((resolve, reject) => {
+        execFile("/usr/bin/osascript", args, { timeout, maxBuffer }, (error, stdout, stderr) => {
+            if (error) {
+                const exitCode = typeof error.code === "number" ? error.code : null;
+                reject(new OsascriptError(stderr || error.message, exitCode));
+                return;
+            }
+            const trimmed = stdout.trim();
+            if (!trimmed) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(trimmed));
+            }
+            catch {
+                // If the output isn't JSON, return the raw string
+                resolve(trimmed);
+            }
+        });
+    });
+}

package/dist/tools/keynote.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerKeynoteTools(server: McpServer): void;

package/dist/tools/keynote.js

@@ -0,0 +1,239 @@
+import { z } from "zod";
+import { runJXA, OsascriptError } from "../jxa.js";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+async function handleJXA(fn) {
+    try {
+        const result = await fn();
+        const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        return toolResult(text);
+    }
+    catch (err) {
+        if (err instanceof OsascriptError) {
+            return toolResult(err.message, true);
+        }
+        return toolResult(String(err), true);
+    }
+}
+export function registerKeynoteTools(server) {
+    // ── Presentation Management ──
+    server.tool("keynote_list_presentations", "List all open Keynote presentations", {}, async () => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const docs = app.documents();
+      return JSON.stringify(docs.map(d => ({ name: d.name(), path: d.file() ? d.file().toString() : null })));
+    `)));
+    server.tool("keynote_create_presentation", "Create a new Keynote presentation (blank or with a theme)", {
+        themeName: z.string().optional().describe("Theme name (optional, e.g. 'White', 'Black', 'Gradient')"),
+    }, async ({ themeName }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      let doc;
+      if (params.themeName) {
+        doc = app.Document({ documentTheme: app.themes[params.themeName] });
+        app.documents.push(doc);
+      } else {
+        doc = app.Document();
+        app.documents.push(doc);
+      }
+      return JSON.stringify({ name: doc.name(), slideCount: doc.slides.length });
+    `, { themeName: themeName ?? null })));
+    server.tool("keynote_open_presentation", "Open a .key file from disk", {
+        filePath: z.string().describe("Absolute path to the .key file"),
+    }, async ({ filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.open(Path(params.filePath));
+      return JSON.stringify({ name: doc.name(), slideCount: doc.slides.length });
+    `, { filePath })));
+    server.tool("keynote_save_presentation", "Save a Keynote presentation", {
+        documentName: z.string().describe("Name of the open presentation"),
+        filePath: z.string().optional().describe("File path to save to (for Save As)"),
+    }, async ({ documentName, filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      if (params.filePath) {
+        doc.save({ in: Path(params.filePath) });
+      } else {
+        doc.save();
+      }
+      return JSON.stringify({ saved: true, name: doc.name() });
+    `, { documentName, filePath: filePath ?? null })));
+    server.tool("keynote_export_presentation", "Export a Keynote presentation to PDF, PowerPoint (.pptx), HTML, or images", {
+        documentName: z.string().describe("Name of the open presentation"),
+        filePath: z.string().describe("Absolute path for the exported file"),
+        format: z.enum(["PDF", "PowerPoint", "HTML", "images"]).describe("Export format"),
+    }, async ({ documentName, filePath, format }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const formatMap = {
+        "PDF": "Keynote PDF",
+        "PowerPoint": "Microsoft PowerPoint",
+        "HTML": "HTML",
+        "images": "slide images",
+      };
+      const fmt = formatMap[params.format];
+      app.export(doc, { to: Path(params.filePath), as: fmt });
+      return JSON.stringify({ exported: true, path: params.filePath, format: params.format });
+    `, { documentName, filePath, format })));
+    server.tool("keynote_close_presentation", "Close a Keynote presentation", {
+        documentName: z.string().describe("Name of the open presentation"),
+        saving: z.enum(["yes", "no", "ask"]).optional().describe("Whether to save before closing"),
+    }, async ({ documentName, saving }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const saveOpts = { yes: "yes", no: "no", ask: "ask" };
+      if (params.saving) {
+        doc.close({ saving: saveOpts[params.saving] });
+      } else {
+        doc.close();
+      }
+      return JSON.stringify({ closed: true });
+    `, { documentName, saving: saving ?? null })));
+    // ── Slide Tools ──
+    server.tool("keynote_list_slides", "List all slides in a presentation with their titles", {
+        documentName: z.string().describe("Name of the open presentation"),
+    }, async ({ documentName }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slides = doc.slides();
+      return JSON.stringify(slides.map((s, i) => {
+        let title = "";
+        try {
+          const titleItem = s.defaultTitleItem();
+          if (titleItem) title = titleItem.objectText();
+        } catch(e) {}
+        return { index: i, slideNumber: i + 1, title: title, skipped: s.skipped() };
+      }));
+    `, { documentName })));
+    server.tool("keynote_add_slide", "Add a new slide to the presentation", {
+        documentName: z.string().describe("Name of the open presentation"),
+        masterSlideName: z.string().optional().describe("Master slide / layout name (e.g. 'Title & Subtitle', 'Blank')"),
+        afterSlide: z.number().optional().describe("Insert after this slide number (1-based). Default: end."),
+    }, async ({ documentName, masterSlideName, afterSlide }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+
+      const props = {};
+      if (params.masterSlideName) {
+        props.baseSlide = doc.masterSlides.byName(params.masterSlideName);
+      }
+
+      const slide = app.Slide(props);
+
+      if (params.afterSlide !== null && params.afterSlide !== undefined) {
+        doc.slides.splice(params.afterSlide, 0, slide);
+      } else {
+        doc.slides.push(slide);
+      }
+
+      return JSON.stringify({ slideNumber: doc.slides.length, added: true });
+    `, { documentName, masterSlideName: masterSlideName ?? null, afterSlide: afterSlide ?? null })));
+    server.tool("keynote_set_slide_title", "Set the title text of a slide", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        title: z.string().describe("Title text"),
+    }, async ({ documentName, slideNumber, title }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      const titleItem = slide.defaultTitleItem();
+      titleItem.objectText = params.title;
+      return JSON.stringify({ slideNumber: params.slideNumber, title: params.title, set: true });
+    `, { documentName, slideNumber, title })));
+    server.tool("keynote_set_slide_body", "Set the body text of a slide (bullet points separated by newlines)", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        body: z.string().describe("Body text (use newlines for bullet points)"),
+    }, async ({ documentName, slideNumber, body }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      const bodyItem = slide.defaultBodyItem();
+      bodyItem.objectText = params.body;
+      return JSON.stringify({ slideNumber: params.slideNumber, set: true });
+    `, { documentName, slideNumber, body })));
+    server.tool("keynote_add_image_to_slide", "Add an image to a slide", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        filePath: z.string().describe("Absolute path to the image file"),
+        x: z.number().optional().describe("X position in points"),
+        y: z.number().optional().describe("Y position in points"),
+        width: z.number().optional().describe("Width in points"),
+        height: z.number().optional().describe("Height in points"),
+    }, async ({ documentName, slideNumber, filePath, x, y, width, height }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      const props = { file: Path(params.filePath) };
+      if (params.x !== null) props.position = [params.x, params.y || 0];
+      if (params.width !== null) props.width = params.width;
+      if (params.height !== null) props.height = params.height;
+      const image = app.Image(props);
+      slide.images.push(image);
+      return JSON.stringify({ added: true, slideNumber: params.slideNumber });
+    `, { documentName, slideNumber, filePath, x: x ?? null, y: y ?? null, width: width ?? null, height: height ?? null })));
+    server.tool("keynote_add_shape", "Add a shape with text to a slide", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        shapeType: z.string().optional().describe("Shape type (e.g. 'rectangle', 'circle', 'rounded rectangle')"),
+        text: z.string().optional().describe("Text content for the shape"),
+        x: z.number().optional().describe("X position in points"),
+        y: z.number().optional().describe("Y position in points"),
+        width: z.number().optional().describe("Width in points (default: 200)"),
+        height: z.number().optional().describe("Height in points (default: 100)"),
+    }, async ({ documentName, slideNumber, shapeType, text, x, y, width, height }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      const props = {};
+      if (params.x !== null && params.y !== null) props.position = [params.x, params.y];
+      if (params.width !== null) props.width = params.width;
+      if (params.height !== null) props.height = params.height;
+      const shape = app.Shape(props);
+      slide.shapes.push(shape);
+      if (params.text) {
+        shape.objectText = params.text;
+      }
+      return JSON.stringify({ added: true, slideNumber: params.slideNumber });
+    `, { documentName, slideNumber, shapeType: shapeType ?? null, text: text ?? null, x: x ?? null, y: y ?? null, width: width ?? 200, height: height ?? 100 })));
+    server.tool("keynote_set_presenter_notes", "Set presenter notes for a slide", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        notes: z.string().describe("Presenter notes text"),
+    }, async ({ documentName, slideNumber, notes }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      slide.presenterNotes = params.notes;
+      return JSON.stringify({ slideNumber: params.slideNumber, set: true });
+    `, { documentName, slideNumber, notes })));
+    server.tool("keynote_set_transition", "Set a transition effect on a slide", {
+        documentName: z.string().describe("Name of the open presentation"),
+        slideNumber: z.number().describe("Slide number (1-based)"),
+        effect: z.string().describe("Transition effect name (e.g. 'dissolve', 'push', 'wipe', 'none')"),
+        duration: z.number().optional().describe("Duration in seconds (default: 1.0)"),
+    }, async ({ documentName, slideNumber, effect, duration }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      const slide = doc.slides[params.slideNumber - 1];
+      const transition = {
+        transitionEffect: params.effect,
+        transitionDuration: params.duration || 1.0,
+      };
+      slide.transitionProperties = transition;
+      return JSON.stringify({ slideNumber: params.slideNumber, effect: params.effect, set: true });
+    `, { documentName, slideNumber, effect, duration: duration ?? null })));
+    server.tool("keynote_start_slideshow", "Start playing the presentation slideshow", {
+        documentName: z.string().describe("Name of the open presentation"),
+        fromSlide: z.number().optional().describe("Start from this slide number (1-based, default: 1)"),
+    }, async ({ documentName, fromSlide }) => handleJXA(() => runJXA(`
+      const app = Application("Keynote");
+      const doc = app.documents.byName(params.documentName);
+      if (params.fromSlide) {
+        doc.slides[params.fromSlide - 1].skipped = false;
+        app.startFrom(doc.slides[params.fromSlide - 1]);
+      } else {
+        app.start(doc);
+      }
+      return JSON.stringify({ playing: true });
+    `, { documentName, fromSlide: fromSlide ?? null })));
+}

package/dist/tools/numbers.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerNumbersTools(server: McpServer): void;

package/dist/tools/numbers.js

@@ -0,0 +1,405 @@
+import { z } from "zod";
+import { runJXA, OsascriptError } from "../jxa.js";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+async function handleJXA(fn) {
+    try {
+        const result = await fn();
+        const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        return toolResult(text);
+    }
+    catch (err) {
+        if (err instanceof OsascriptError) {
+            return toolResult(err.message, true);
+        }
+        return toolResult(String(err), true);
+    }
+}
+export function registerNumbersTools(server) {
+    // ── Document Management ──
+    server.tool("numbers_list_documents", "List all open Numbers documents", {}, async () => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const docs = app.documents();
+      return JSON.stringify(docs.map(d => ({ name: d.name(), path: d.file() ? d.file().toString() : null })));
+    `)));
+    server.tool("numbers_create_document", "Create a new blank Numbers document", {
+        templateName: z.string().optional().describe("Template name (optional)"),
+    }, async ({ templateName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      let doc;
+      if (params.templateName) {
+        doc = app.Document({ documentTemplate: app.templates[params.templateName] });
+        app.documents.push(doc);
+      } else {
+        doc = app.Document();
+        app.documents.push(doc);
+      }
+      return JSON.stringify({ name: doc.name(), sheets: doc.sheets().map(s => s.name()) });
+    `, { templateName: templateName ?? null })));
+    server.tool("numbers_open_document", "Open a .numbers file from disk", {
+        filePath: z.string().describe("Absolute path to the .numbers file"),
+    }, async ({ filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.open(Path(params.filePath));
+      return JSON.stringify({ name: doc.name(), sheets: doc.sheets().map(s => s.name()) });
+    `, { filePath })));
+    server.tool("numbers_save_document", "Save a Numbers document", {
+        documentName: z.string().describe("Name of the open document"),
+        filePath: z.string().optional().describe("File path to save to (for Save As)"),
+    }, async ({ documentName, filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      if (params.filePath) {
+        doc.save({ in: Path(params.filePath) });
+      } else {
+        doc.save();
+      }
+      return JSON.stringify({ saved: true, name: doc.name() });
+    `, { documentName, filePath: filePath ?? null })));
+    server.tool("numbers_export_document", "Export a Numbers document to PDF, Excel (.xlsx), or CSV", {
+        documentName: z.string().describe("Name of the open document"),
+        filePath: z.string().describe("Absolute path for the exported file"),
+        format: z.enum(["PDF", "Excel", "CSV"]).describe("Export format"),
+    }, async ({ documentName, filePath, format }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const formatMap = {
+        "PDF": "Numbers PDF",
+        "Excel": "Microsoft Excel",
+        "CSV": "CSV",
+      };
+      const fmt = formatMap[params.format];
+      app.export(doc, { to: Path(params.filePath), as: fmt });
+      return JSON.stringify({ exported: true, path: params.filePath, format: params.format });
+    `, { documentName, filePath, format })));
+    server.tool("numbers_close_document", "Close a Numbers document", {
+        documentName: z.string().describe("Name of the open document"),
+        saving: z.enum(["yes", "no", "ask"]).optional().describe("Whether to save before closing"),
+    }, async ({ documentName, saving }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const saveOpts = { yes: "yes", no: "no", ask: "ask" };
+      if (params.saving) {
+        doc.close({ saving: saveOpts[params.saving] });
+      } else {
+        doc.close();
+      }
+      return JSON.stringify({ closed: true });
+    `, { documentName, saving: saving ?? null })));
+    // ── Structure Tools ──
+    server.tool("numbers_list_sheets", "List all sheets in a Numbers document", {
+        documentName: z.string().describe("Name of the open document"),
+    }, async ({ documentName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheets = doc.sheets();
+      return JSON.stringify(sheets.map((s, i) => ({
+        index: i,
+        name: s.name(),
+        tableCount: s.tables.length,
+      })));
+    `, { documentName })));
+    server.tool("numbers_add_sheet", "Add a new sheet to a Numbers document", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Name for the new sheet"),
+    }, async ({ documentName, sheetName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = app.Sheet();
+      doc.sheets.push(sheet);
+      if (params.sheetName) {
+        sheet.name = params.sheetName;
+      }
+      return JSON.stringify({ name: sheet.name(), index: doc.sheets.length - 1 });
+    `, { documentName, sheetName: sheetName ?? null })));
+    server.tool("numbers_list_tables", "List all tables in a sheet with their dimensions", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+    }, async ({ documentName, sheetName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const tables = sheet.tables();
+      return JSON.stringify(tables.map((t, i) => ({
+        index: i,
+        name: t.name(),
+        rowCount: t.rowCount(),
+        columnCount: t.columnCount(),
+        headerRowCount: t.headerRowCount(),
+        headerColumnCount: t.headerColumnCount(),
+      })));
+    `, { documentName, sheetName: sheetName ?? null })));
+    server.tool("numbers_add_table", "Create a new table in a sheet", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Name for the new table"),
+        rows: z.number().optional().describe("Number of rows (default: 4)"),
+        columns: z.number().optional().describe("Number of columns (default: 4)"),
+    }, async ({ documentName, sheetName, tableName, rows, columns }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const props = {};
+      if (params.rows) props.rowCount = params.rows;
+      if (params.columns) props.columnCount = params.columns;
+      const table = app.Table(props);
+      sheet.tables.push(table);
+      if (params.tableName) {
+        table.name = params.tableName;
+      }
+      return JSON.stringify({
+        name: table.name(),
+        rowCount: table.rowCount(),
+        columnCount: table.columnCount(),
+      });
+    `, { documentName, sheetName: sheetName ?? null, tableName: tableName ?? null, rows: rows ?? null, columns: columns ?? null })));
+    // ── Data Reading Tools ──
+    server.tool("numbers_read_table", "Read all data from a table as a 2D array. Returns rows of cell values.", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      const rowCount = table.rowCount();
+      const colCount = table.columnCount();
+      const data = [];
+      for (let r = 0; r < rowCount; r++) {
+        const row = [];
+        for (let c = 0; c < colCount; c++) {
+          const cell = table.cells[r * colCount + c];
+          row.push(cell.value());
+        }
+        data.push(row);
+      }
+      return JSON.stringify(data);
+    `, { documentName, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_read_cell", "Read a single cell's value", {
+        documentName: z.string().describe("Name of the open document"),
+        cellRef: z.string().describe("Cell reference, e.g. 'A1', 'B3'"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, cellRef, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      const cell = table.cells[params.cellRef];
+      return JSON.stringify({ cellRef: params.cellRef, value: cell.value(), formattedValue: cell.formattedValue() });
+    `, { documentName, cellRef, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_get_table_info", "Get table metadata: row/column counts, header info, table name", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      return JSON.stringify({
+        name: table.name(),
+        rowCount: table.rowCount(),
+        columnCount: table.columnCount(),
+        headerRowCount: table.headerRowCount(),
+        headerColumnCount: table.headerColumnCount(),
+        footerRowCount: table.footerRowCount(),
+      });
+    `, { documentName, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    // ── Data Writing Tools ──
+    server.tool("numbers_write_cell", "Write a value to a cell", {
+        documentName: z.string().describe("Name of the open document"),
+        cellRef: z.string().describe("Cell reference, e.g. 'A1', 'B3'"),
+        value: z.union([z.string(), z.number(), z.boolean()]).describe("Value to write"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, cellRef, value, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      table.cells[params.cellRef].value = params.value;
+      return JSON.stringify({ cellRef: params.cellRef, written: true });
+    `, { documentName, cellRef, value, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_write_cells", "Batch write multiple cell values in a single operation", {
+        documentName: z.string().describe("Name of the open document"),
+        writes: z.array(z.object({
+            cellRef: z.string().describe("Cell reference, e.g. 'A1'"),
+            value: z.union([z.string(), z.number(), z.boolean()]).describe("Value to write"),
+        })).describe("Array of cell writes"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, writes, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      const results = [];
+      for (const w of params.writes) {
+        table.cells[w.cellRef].value = w.value;
+        results.push({ cellRef: w.cellRef, written: true });
+      }
+      return JSON.stringify(results);
+    `, { documentName, writes, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_set_formula", "Set a formula on a cell (e.g. '=SUM(A1:A10)')", {
+        documentName: z.string().describe("Name of the open document"),
+        cellRef: z.string().describe("Cell reference, e.g. 'A1'"),
+        formula: z.string().describe("Formula string (e.g. '=SUM(A1:A10)')"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, cellRef, formula, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      table.cells[params.cellRef].value = params.formula;
+      return JSON.stringify({ cellRef: params.cellRef, formula: params.formula, set: true });
+    `, { documentName, cellRef, formula, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_add_row", "Add one or more rows at the end of a table, optionally with data", {
+        documentName: z.string().describe("Name of the open document"),
+        data: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).optional()
+            .describe("2D array of row data to populate (each inner array is one row)"),
+        position: z.enum(["end", "beginning"]).optional().describe("Where to add the row (default: end)"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, data, position, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+
+      const rowsToAdd = params.data ? params.data.length : 1;
+      const colCount = table.columnCount();
+      const pos = params.position === "beginning" ? 0 : table.rowCount();
+
+      for (let i = 0; i < rowsToAdd; i++) {
+        table.rows.push(app.Row());
+      }
+
+      if (params.data) {
+        const startRow = pos;
+        for (let r = 0; r < params.data.length; r++) {
+          for (let c = 0; c < Math.min(params.data[r].length, colCount); c++) {
+            if (params.data[r][c] !== null) {
+              table.cells[(startRow + r) * colCount + c].value = params.data[r][c];
+            }
+          }
+        }
+      }
+
+      return JSON.stringify({ rowsAdded: rowsToAdd, newRowCount: table.rowCount() });
+    `, { documentName, data: data ?? null, position: position ?? null, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_add_column", "Add a column to a table", {
+        documentName: z.string().describe("Name of the open document"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      table.columns.push(app.Column());
+      return JSON.stringify({ newColumnCount: table.columnCount() });
+    `, { documentName, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    // ── Formatting Tools ──
+    server.tool("numbers_format_cells", "Set formatting on a cell or range: font, size, color, alignment, background color", {
+        documentName: z.string().describe("Name of the open document"),
+        cellRange: z.string().describe("Cell or range reference, e.g. 'A1' or 'A1:C3'"),
+        format: z.object({
+            bold: z.boolean().optional().describe("Set bold"),
+            italic: z.boolean().optional().describe("Set italic"),
+            fontSize: z.number().optional().describe("Font size in points"),
+            fontName: z.string().optional().describe("Font name"),
+            textColor: z.string().optional().describe("Text color as hex, e.g. '#FF0000'"),
+            backgroundColor: z.string().optional().describe("Background color as hex, e.g. '#0000FF'"),
+            alignment: z.enum(["left", "center", "right", "auto"]).optional().describe("Text alignment"),
+        }).describe("Formatting options"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, cellRange, format, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      const fmt = params.format;
+
+      // Parse range like "A1:C3" into individual cells
+      const rangeStr = params.cellRange;
+      let cells = [];
+      if (rangeStr.includes(":")) {
+        const range = table.ranges[rangeStr];
+        cells = range.cells();
+      } else {
+        cells = [table.cells[rangeStr]];
+      }
+
+      function hexToRGB(hex) {
+        const r = parseInt(hex.slice(1, 3), 16) / 255;
+        const g = parseInt(hex.slice(3, 5), 16) / 255;
+        const b = parseInt(hex.slice(5, 7), 16) / 255;
+        return [r, g, b];
+      }
+
+      for (const cell of cells) {
+        if (fmt.bold !== undefined) cell.textColor = cell.textColor; // touch to ensure access
+        if (fmt.fontSize !== undefined) cell.fontSize = fmt.fontSize;
+        if (fmt.fontName !== undefined) cell.fontName = fmt.fontName;
+        if (fmt.textColor !== undefined) {
+          const [r, g, b] = hexToRGB(fmt.textColor);
+          cell.textColor = [r, g, b];
+        }
+        if (fmt.backgroundColor !== undefined) {
+          const [r, g, b] = hexToRGB(fmt.backgroundColor);
+          cell.backgroundColor = [r, g, b];
+        }
+        if (fmt.alignment !== undefined) {
+          const alignMap = { left: "left", center: "center", right: "right", auto: "auto" };
+          cell.alignment = alignMap[fmt.alignment];
+        }
+        if (fmt.bold !== undefined) {
+          cell.format = cell.format; // Numbers doesn't have direct bold; we use font
+        }
+      }
+
+      return JSON.stringify({ formatted: true, cellRange: params.cellRange });
+    `, { documentName, cellRange, format, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_set_column_width", "Set the width of a column", {
+        documentName: z.string().describe("Name of the open document"),
+        column: z.string().describe("Column letter, e.g. 'A', 'B'"),
+        width: z.number().describe("Width in points"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, column, width, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+
+      // Convert column letter to index (A=0, B=1, ...)
+      const colStr = params.column.toUpperCase();
+      let colIndex = 0;
+      for (let i = 0; i < colStr.length; i++) {
+        colIndex = colIndex * 26 + (colStr.charCodeAt(i) - 64);
+      }
+      colIndex -= 1;
+
+      table.columns[colIndex].width = params.width;
+      return JSON.stringify({ column: params.column, width: params.width, set: true });
+    `, { documentName, column, width, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+    server.tool("numbers_set_row_height", "Set the height of a row", {
+        documentName: z.string().describe("Name of the open document"),
+        row: z.number().describe("Row number (1-based)"),
+        height: z.number().describe("Height in points"),
+        sheetName: z.string().optional().describe("Sheet name (defaults to first sheet)"),
+        tableName: z.string().optional().describe("Table name (defaults to first table)"),
+    }, async ({ documentName, row, height, sheetName, tableName }) => handleJXA(() => runJXA(`
+      const app = Application("Numbers");
+      const doc = app.documents.byName(params.documentName);
+      const sheet = params.sheetName ? doc.sheets.byName(params.sheetName) : doc.sheets[0];
+      const table = params.tableName ? sheet.tables.byName(params.tableName) : sheet.tables[0];
+      table.rows[params.row - 1].height = params.height;
+      return JSON.stringify({ row: params.row, height: params.height, set: true });
+    `, { documentName, row, height, sheetName: sheetName ?? null, tableName: tableName ?? null })));
+}

package/dist/tools/pages.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPagesTools(server: McpServer): void;

package/dist/tools/pages.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { runJXA, OsascriptError } from "../jxa.js";
+function toolResult(text, isError = false) {
+    return { content: [{ type: "text", text }], isError };
+}
+async function handleJXA(fn) {
+    try {
+        const result = await fn();
+        const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        return toolResult(text);
+    }
+    catch (err) {
+        if (err instanceof OsascriptError) {
+            return toolResult(err.message, true);
+        }
+        return toolResult(String(err), true);
+    }
+}
+export function registerPagesTools(server) {
+    // ── Document Management ──
+    server.tool("pages_list_documents", "List all open Pages documents", {}, async () => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const docs = app.documents();
+      return JSON.stringify(docs.map(d => ({ name: d.name(), path: d.file() ? d.file().toString() : null })));
+    `)));
+    server.tool("pages_create_document", "Create a new blank Pages document (or from a template)", {
+        templateName: z.string().optional().describe("Template name (optional)"),
+    }, async ({ templateName }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      let doc;
+      if (params.templateName) {
+        doc = app.Document({ documentTemplate: app.templates[params.templateName] });
+        app.documents.push(doc);
+      } else {
+        doc = app.Document();
+        app.documents.push(doc);
+      }
+      return JSON.stringify({ name: doc.name() });
+    `, { templateName: templateName ?? null })));
+    server.tool("pages_open_document", "Open a .pages file from disk", {
+        filePath: z.string().describe("Absolute path to the .pages file"),
+    }, async ({ filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.open(Path(params.filePath));
+      return JSON.stringify({ name: doc.name() });
+    `, { filePath })));
+    server.tool("pages_save_document", "Save a Pages document", {
+        documentName: z.string().describe("Name of the open document"),
+        filePath: z.string().optional().describe("File path to save to (for Save As)"),
+    }, async ({ documentName, filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      if (params.filePath) {
+        doc.save({ in: Path(params.filePath) });
+      } else {
+        doc.save();
+      }
+      return JSON.stringify({ saved: true, name: doc.name() });
+    `, { documentName, filePath: filePath ?? null })));
+    server.tool("pages_export_document", "Export a Pages document to PDF, Word (.docx), EPUB, or plain text", {
+        documentName: z.string().describe("Name of the open document"),
+        filePath: z.string().describe("Absolute path for the exported file"),
+        format: z.enum(["PDF", "Word", "EPUB", "Text"]).describe("Export format"),
+    }, async ({ documentName, filePath, format }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const formatMap = {
+        "PDF": "Pages PDF",
+        "Word": "Microsoft Word",
+        "EPUB": "EPUB",
+        "Text": "unformatted text",
+      };
+      const fmt = formatMap[params.format];
+      app.export(doc, { to: Path(params.filePath), as: fmt });
+      return JSON.stringify({ exported: true, path: params.filePath, format: params.format });
+    `, { documentName, filePath, format })));
+    server.tool("pages_close_document", "Close a Pages document", {
+        documentName: z.string().describe("Name of the open document"),
+        saving: z.enum(["yes", "no", "ask"]).optional().describe("Whether to save before closing"),
+    }, async ({ documentName, saving }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const saveOpts = { yes: "yes", no: "no", ask: "ask" };
+      if (params.saving) {
+        doc.close({ saving: saveOpts[params.saving] });
+      } else {
+        doc.close();
+      }
+      return JSON.stringify({ closed: true });
+    `, { documentName, saving: saving ?? null })));
+    // ── Text Reading Tools ──
+    server.tool("pages_get_body_text", "Read all body text from a Pages document", {
+        documentName: z.string().describe("Name of the open document"),
+    }, async ({ documentName }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const text = doc.bodyText();
+      return JSON.stringify({ text: text });
+    `, { documentName })));
+    server.tool("pages_get_paragraphs", "Get all paragraphs from a Pages document as an indexed array", {
+        documentName: z.string().describe("Name of the open document"),
+    }, async ({ documentName }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const paragraphs = doc.paragraphs();
+      return JSON.stringify(paragraphs.map((p, i) => ({
+        index: i,
+        text: p.text ? p.text() : "",
+      })));
+    `, { documentName })));
+    // ── Text Writing Tools ──
+    server.tool("pages_add_text", "Append text to the end of the document body", {
+        documentName: z.string().describe("Name of the open document"),
+        text: z.string().describe("Text to append"),
+    }, async ({ documentName, text }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const current = doc.bodyText();
+      doc.bodyText = current + params.text;
+      return JSON.stringify({ appended: true });
+    `, { documentName, text })));
+    server.tool("pages_replace_text", "Find and replace text in a Pages document", {
+        documentName: z.string().describe("Name of the open document"),
+        find: z.string().describe("Text to find"),
+        replace: z.string().describe("Replacement text"),
+        all: z.boolean().optional().describe("Replace all occurrences (default: true)"),
+    }, async ({ documentName, find, replace, all }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const current = doc.bodyText();
+      let count = 0;
+      let newText;
+      if (params.all !== false) {
+        const parts = current.split(params.find);
+        count = parts.length - 1;
+        newText = parts.join(params.replace);
+      } else {
+        const idx = current.indexOf(params.find);
+        if (idx !== -1) {
+          newText = current.substring(0, idx) + params.replace + current.substring(idx + params.find.length);
+          count = 1;
+        } else {
+          newText = current;
+        }
+      }
+      doc.bodyText = newText;
+      return JSON.stringify({ replacements: count });
+    `, { documentName, find, replace, all: all ?? true })));
+    server.tool("pages_format_text", "Set formatting on a paragraph: font, size, color, bold, italic", {
+        documentName: z.string().describe("Name of the open document"),
+        paragraphIndex: z.number().describe("Paragraph index (0-based)"),
+        format: z.object({
+            bold: z.boolean().optional().describe("Set bold"),
+            italic: z.boolean().optional().describe("Set italic"),
+            fontSize: z.number().optional().describe("Font size in points"),
+            fontName: z.string().optional().describe("Font name"),
+            textColor: z.string().optional().describe("Text color as hex, e.g. '#FF0000'"),
+        }).describe("Formatting options"),
+    }, async ({ documentName, paragraphIndex, format }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const paragraph = doc.paragraphs[params.paragraphIndex];
+      const fmt = params.format;
+
+      if (fmt.fontSize !== undefined) paragraph.fontSize = fmt.fontSize;
+      if (fmt.fontName !== undefined) paragraph.fontName = fmt.fontName;
+      if (fmt.bold !== undefined) paragraph.bold = fmt.bold;
+      if (fmt.italic !== undefined) paragraph.italic = fmt.italic;
+      if (fmt.textColor !== undefined) {
+        const hex = fmt.textColor;
+        const r = parseInt(hex.slice(1, 3), 16) / 255;
+        const g = parseInt(hex.slice(3, 5), 16) / 255;
+        const b = parseInt(hex.slice(5, 7), 16) / 255;
+        paragraph.color = [r, g, b];
+      }
+
+      return JSON.stringify({ formatted: true, paragraphIndex: params.paragraphIndex });
+    `, { documentName, paragraphIndex, format })));
+    server.tool("pages_add_image", "Insert an image into the document", {
+        documentName: z.string().describe("Name of the open document"),
+        filePath: z.string().describe("Absolute path to the image file"),
+    }, async ({ documentName, filePath }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const image = app.Image({ file: Path(params.filePath) });
+      doc.images.push(image);
+      return JSON.stringify({ added: true, path: params.filePath });
+    `, { documentName, filePath })));
+    server.tool("pages_add_table", "Insert a table into the document", {
+        documentName: z.string().describe("Name of the open document"),
+        rows: z.number().optional().describe("Number of rows (default: 3)"),
+        columns: z.number().optional().describe("Number of columns (default: 3)"),
+    }, async ({ documentName, rows, columns }) => handleJXA(() => runJXA(`
+      const app = Application("Pages");
+      const doc = app.documents.byName(params.documentName);
+      const props = {};
+      if (params.rows) props.rowCount = params.rows;
+      if (params.columns) props.columnCount = params.columns;
+      const table = app.Table(props);
+      doc.tables.push(table);
+      return JSON.stringify({ added: true, name: table.name() });
+    `, { documentName, rows: rows ?? null, columns: columns ?? null })));
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "iwork-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Apple iWork (Numbers, Pages, Keynote) automation",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "iwork-mcp": "dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsc --watch",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}