mcp-omnifocus 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mcp-omnifocus contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# MCP OmniFocus
+
+MCP server for OmniFocus with auto-detection of Pro/Standard version.
+
+## Features
+
+- **Auto-detection**: Automatically detects OmniFocus Pro or Standard
+- **Full Pro support**: AppleScript for read/write with sync
+- **Standard fallback**: SQLite read + URL scheme for create
+
+### Capabilities by Version
+
+| Feature | Pro (AppleScript) | Standard |
+|---------|-------------------|----------|
+| Read tasks | ✓ | ✓ (SQLite) |
+| Create task | ✓ | ✓ (URL scheme, syncs) |
+| Update task | ✓ | ⚠️ (SQLite, no sync) |
+| Complete task | ✓ | ⚠️ (SQLite, no sync) |
+| Get projects | ✓ | ✓ (SQLite) |
+
+**⚠️ Standard SQLite write**: Changes don't sync until OmniFocus restart.
+
+## Installation
+
+```bash
+cd ~/Projects/mcp-omnifocus
+npm install
+npm run build
+```
+
+## Claude Code Configuration
+
+Add to `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "omnifocus": {
+      "command": "node",
+      "args": ["/Users/YOUR_USERNAME/Projects/mcp-omnifocus/dist/index.js"]
+    }
+  }
+}
+```
+
+## Tools
+
+### omnifocus_get_tasks
+Get tasks filtered by flagged, due today, or all.
+
+### omnifocus_create_task
+Create a new task with name, note, project, flagged, dueDate.
+
+### omnifocus_update_task
+Update existing task (Pro: syncs, Standard: SQLite only).
+
+### omnifocus_complete_task
+Mark task as complete (Pro: syncs, Standard: SQLite only).
+
+### omnifocus_get_projects
+Get list of active projects.

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createRequire } from "module";
+import { ZodError } from "zod";
+const require = createRequire(import.meta.url);
+const { version: PACKAGE_VERSION } = require("../package.json");
+import { detectVersion } from "./version-detector.js";
+import { AppleScriptProvider } from "./providers/applescript.js";
+import { UrlSchemeProvider } from "./providers/url-scheme.js";
+import { CreateTaskInputSchema, UpdateTaskInputSchema, CompleteTaskInputSchema, GetTasksInputSchema, SetConfigInputSchema, } from "./validation.js";
+function sanitizeErrorMessage(error) {
+    if (error instanceof ZodError) {
+        return error.errors.map(e => `${e.path.join(".")}: ${e.message}`).join("; ");
+    }
+    if (error instanceof Error) {
+        const msg = error.message;
+        // remove file paths and sensitive info
+        return msg
+            .replace(/\/Users\/[^/\s]+/g, "/Users/***")
+            .replace(/\/home\/[^/\s]+/g, "/home/***")
+            .replace(/at\s+.+:\d+:\d+/g, "")
+            .trim();
+    }
+    return "An unexpected error occurred";
+}
+let provider;
+const server = new Server({
+    name: "mcp-omnifocus",
+    version: PACKAGE_VERSION,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const version = provider.version;
+    const writeWarning = version === "standard"
+        ? " (Standard version: changes via SQLite won't sync until OmniFocus restart)"
+        : "";
+    return {
+        tools: [
+            {
+                name: "omnifocus_get_tasks",
+                description: `Get tasks from OmniFocus. Filter by flagged, due today, or all. Detected version: ${version}`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filter: {
+                            type: "string",
+                            enum: ["flagged", "due_today", "all"],
+                            description: "Filter tasks: flagged, due_today, or all (default: flagged + due today)"
+                        }
+                    }
+                }
+            },
+            {
+                name: "omnifocus_create_task",
+                description: `Create a new task in OmniFocus. Detected version: ${version}`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Task name (required)"
+                        },
+                        note: {
+                            type: "string",
+                            description: "Task note/description"
+                        },
+                        project: {
+                            type: "string",
+                            description: "Project name to add task to (optional, defaults to inbox)"
+                        },
+                        flagged: {
+                            type: "boolean",
+                            description: "Mark task as flagged"
+                        },
+                        dueDate: {
+                            type: "string",
+                            description: "Due date in ISO format (YYYY-MM-DD)"
+                        }
+                    },
+                    required: ["name"]
+                }
+            },
+            {
+                name: "omnifocus_update_task",
+                description: `Update an existing task in OmniFocus.${writeWarning}`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (required)"
+                        },
+                        name: {
+                            type: "string",
+                            description: "New task name"
+                        },
+                        note: {
+                            type: "string",
+                            description: "New task note"
+                        },
+                        flagged: {
+                            type: "boolean",
+                            description: "Set flagged status"
+                        },
+                        dueDate: {
+                            type: "string",
+                            description: "New due date in ISO format"
+                        }
+                    },
+                    required: ["taskId"]
+                }
+            },
+            {
+                name: "omnifocus_complete_task",
+                description: `Mark a task as complete.${writeWarning}`,
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "string",
+                            description: "Task ID to complete (required)"
+                        }
+                    },
+                    required: ["taskId"]
+                }
+            },
+            {
+                name: "omnifocus_get_projects",
+                description: `Get list of active projects from OmniFocus. Detected version: ${version}`,
+                inputSchema: {
+                    type: "object",
+                    properties: {}
+                }
+            },
+            {
+                name: "omnifocus_get_config",
+                description: "Get current configuration settings",
+                inputSchema: {
+                    type: "object",
+                    properties: {}
+                }
+            },
+            {
+                name: "omnifocus_set_config",
+                description: "Update configuration settings. For Standard version: directSqlAccess controls whether to use direct SQLite access for update/complete operations (faster but requires OmniFocus restart to sync)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        directSqlAccess: {
+                            type: "boolean",
+                            description: "Enable direct SQLite access for write operations (Standard version only)"
+                        },
+                        taskLimit: {
+                            type: "number",
+                            description: "Maximum number of tasks to return from getTasks (default: 500, max: 10000)"
+                        }
+                    }
+                }
+            }
+        ]
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "omnifocus_get_tasks": {
+                const input = GetTasksInputSchema.parse(args ?? {});
+                const tasks = await provider.getTasks(input.filter);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ version: provider.version, tasks }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_create_task": {
+                const input = CreateTaskInputSchema.parse(args ?? {});
+                const result = await provider.createTask(input);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ version: provider.version, ...result }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_update_task": {
+                const input = UpdateTaskInputSchema.parse(args ?? {});
+                const result = await provider.updateTask(input);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ version: provider.version, ...result }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_complete_task": {
+                const input = CompleteTaskInputSchema.parse(args ?? {});
+                const result = await provider.completeTask(input.taskId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ version: provider.version, ...result }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_get_projects": {
+                const projects = await provider.getProjects();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ version: provider.version, projects }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_get_config": {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                version: provider.version,
+                                config: provider.config
+                            }, null, 2)
+                        }]
+                };
+            }
+            case "omnifocus_set_config": {
+                const input = SetConfigInputSchema.parse(args ?? {});
+                provider.setConfig(input);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                version: provider.version,
+                                config: provider.config
+                            }, null, 2)
+                        }]
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        console.error("[mcp-omnifocus] Error:", error);
+        const message = sanitizeErrorMessage(error);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ error: message }, null, 2)
+                }],
+            isError: true
+        };
+    }
+});
+async function main() {
+    console.error("[mcp-omnifocus] Starting...");
+    const version = await detectVersion();
+    console.error(`[mcp-omnifocus] Detected OmniFocus version: ${version}`);
+    provider = version === "pro"
+        ? new AppleScriptProvider()
+        : new UrlSchemeProvider();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[mcp-omnifocus] Server connected");
+}
+main().catch((error) => {
+    console.error("[mcp-omnifocus] Fatal error:", error);
+    process.exit(1);
+});

package/dist/providers/applescript.d.ts

@@ -0,0 +1,19 @@
+import type { OmniFocusProvider, OmniFocusTask, CreateTaskInput, UpdateTaskInput, OmniFocusConfig } from "../types.js";
+export declare function escapeAppleScriptString(str: string): string;
+export declare class AppleScriptProvider implements OmniFocusProvider {
+    version: "pro";
+    config: OmniFocusConfig;
+    setConfig(newConfig: Partial<OmniFocusConfig>): void;
+    getTasks(filter?: "flagged" | "due_today" | "all"): Promise<OmniFocusTask[]>;
+    createTask(input: CreateTaskInput): Promise<{
+        success: boolean;
+        taskId?: string;
+    }>;
+    updateTask(input: UpdateTaskInput): Promise<{
+        success: boolean;
+    }>;
+    completeTask(taskId: string): Promise<{
+        success: boolean;
+    }>;
+    getProjects(): Promise<string[]>;
+}

package/dist/providers/applescript.js

@@ -0,0 +1,204 @@
+import { spawn } from "child_process";
+import { DEFAULT_TASK_LIMIT } from "../types.js";
+async function runAppleScript(script) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("osascript", ["-"], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`AppleScript failed: ${stderr.trim() || "Unknown error"}`));
+            }
+        });
+        child.on("error", (err) => {
+            reject(err);
+        });
+        child.stdin.write(script);
+        child.stdin.end();
+    });
+}
+export function escapeAppleScriptString(str) {
+    return str
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\r/g, "\\r")
+        .replace(/\n/g, "\\n")
+        .replace(/\t/g, "\\t");
+}
+export class AppleScriptProvider {
+    version = "pro";
+    config = { directSqlAccess: false, taskLimit: DEFAULT_TASK_LIMIT };
+    setConfig(newConfig) {
+        // AppleScript provider doesn't use SQL, config is ignored
+        Object.assign(this.config, newConfig);
+    }
+    async getTasks(filter) {
+        let condition = "";
+        if (filter === "flagged") {
+            condition = "whose flagged is true";
+        }
+        else if (filter === "due_today") {
+            condition = "whose due date is not missing value and due date < (current date) + 1 * days";
+        }
+        const script = `
+      tell application "OmniFocus"
+        tell default document
+          set taskList to {}
+          set theTasks to flattened tasks ${condition}
+          repeat with t in theTasks
+            if completed of t is false then
+              set taskId to id of t
+              set taskName to name of t
+              set taskNote to note of t
+              set taskFlagged to flagged of t
+              set taskDue to ""
+              if due date of t is not missing value then
+                set taskDue to (due date of t) as «class isot» as string
+              end if
+              set projectName to ""
+              try
+                set projectName to name of containing project of t
+              end try
+              set end of taskList to taskId & "|||" & taskName & "|||" & taskNote & "|||" & taskFlagged & "|||" & taskDue & "|||" & projectName
+            end if
+          end repeat
+          set AppleScript's text item delimiters to "
+---TASK---
+"
+          return taskList as text
+        end tell
+      end tell
+    `;
+        const result = await runAppleScript(script);
+        if (!result)
+            return [];
+        // use newline-based delimiter to handle commas in task names
+        return result.split("\n---TASK---\n").map(line => {
+            const [id, name, note, flagged, dueDate, project] = line.split("|||");
+            return {
+                id,
+                name,
+                note: note || undefined,
+                flagged: flagged === "true",
+                dueDate: dueDate || undefined,
+                project: project || undefined,
+                completed: false
+            };
+        });
+    }
+    async createTask(input) {
+        const escapedName = escapeAppleScriptString(input.name);
+        const props = [`name:"${escapedName}"`];
+        if (input.note) {
+            const escapedNote = escapeAppleScriptString(input.note);
+            props.push(`note:"${escapedNote}"`);
+        }
+        if (input.flagged) {
+            props.push("flagged:true");
+        }
+        if (input.dueDate) {
+            const escapedDate = escapeAppleScriptString(input.dueDate);
+            props.push(`due date:date "${escapedDate}"`);
+        }
+        let script;
+        if (input.project) {
+            const escapedProject = escapeAppleScriptString(input.project);
+            script = `
+        tell application "OmniFocus"
+          tell default document
+            set theProject to first flattened project whose name is "${escapedProject}"
+            set newTask to make new task with properties {${props.join(", ")}} at end of tasks of theProject
+            return id of newTask
+          end tell
+        end tell
+      `;
+        }
+        else {
+            script = `
+        tell application "OmniFocus"
+          tell default document
+            set newTask to make new inbox task with properties {${props.join(", ")}}
+            return id of newTask
+          end tell
+        end tell
+      `;
+        }
+        const taskId = await runAppleScript(script);
+        return { success: true, taskId };
+    }
+    async updateTask(input) {
+        const updates = [];
+        const escapedTaskId = escapeAppleScriptString(input.taskId);
+        if (input.name) {
+            const escapedName = escapeAppleScriptString(input.name);
+            updates.push(`set name of theTask to "${escapedName}"`);
+        }
+        if (input.note !== undefined) {
+            const escapedNote = escapeAppleScriptString(input.note);
+            updates.push(`set note of theTask to "${escapedNote}"`);
+        }
+        if (input.flagged !== undefined) {
+            updates.push(`set flagged of theTask to ${input.flagged}`);
+        }
+        if (input.dueDate) {
+            const escapedDate = escapeAppleScriptString(input.dueDate);
+            updates.push(`set due date of theTask to date "${escapedDate}"`);
+        }
+        const script = `
+      tell application "OmniFocus"
+        tell default document
+          set theTask to first flattened task whose id is "${escapedTaskId}"
+          ${updates.join("\n          ")}
+        end tell
+      end tell
+    `;
+        await runAppleScript(script);
+        return { success: true };
+    }
+    async completeTask(taskId) {
+        const escapedTaskId = escapeAppleScriptString(taskId);
+        const script = `
+      tell application "OmniFocus"
+        tell default document
+          set theTask to first flattened task whose id is "${escapedTaskId}"
+          set completed of theTask to true
+        end tell
+      end tell
+    `;
+        await runAppleScript(script);
+        return { success: true };
+    }
+    async getProjects() {
+        const script = `
+      tell application "OmniFocus"
+        tell default document
+          set projectNames to {}
+          repeat with p in flattened projects
+            if status of p is active then
+              set end of projectNames to name of p
+            end if
+          end repeat
+          set AppleScript's text item delimiters to "
+---PROJECT---
+"
+          return projectNames as text
+        end tell
+      end tell
+    `;
+        const result = await runAppleScript(script);
+        if (!result)
+            return [];
+        return result.split("\n---PROJECT---\n");
+    }
+}

package/dist/providers/url-scheme.d.ts

@@ -0,0 +1,20 @@
+import type { OmniFocusProvider, OmniFocusTask, CreateTaskInput, UpdateTaskInput, OmniFocusConfig } from "../types.js";
+export declare class UrlSchemeProvider implements OmniFocusProvider {
+    version: "standard";
+    config: OmniFocusConfig;
+    setConfig(newConfig: Partial<OmniFocusConfig>): void;
+    getTasks(filter?: "flagged" | "due_today" | "all"): Promise<OmniFocusTask[]>;
+    createTask(input: CreateTaskInput): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    updateTask(input: UpdateTaskInput): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    completeTask(taskId: string): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    getProjects(): Promise<string[]>;
+}

package/dist/providers/url-scheme.js

@@ -0,0 +1,178 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { homedir } from "os";
+import Database from "better-sqlite3";
+import { DEFAULT_TASK_LIMIT } from "../types.js";
+const execFileAsync = promisify(execFile);
+const DB_PATH = `${homedir()}/Library/Group Containers/34YW5XSRB7.com.omnigroup.OmniFocus/com.omnigroup.OmniFocus4/com.omnigroup.OmniFocusModel/OmniFocusDatabase.db`;
+// Core Data (Apple) uses 2001-01-01 as epoch, Unix uses 1970-01-01
+// difference is ~31 years (978307200 seconds)
+const CORE_DATA_EPOCH_MS = new Date("2001-01-01T00:00:00Z").getTime();
+function getDatabase(readonly = true) {
+    return new Database(DB_PATH, { readonly, fileMustExist: true });
+}
+export class UrlSchemeProvider {
+    version = "standard";
+    config = { directSqlAccess: true, taskLimit: DEFAULT_TASK_LIMIT };
+    setConfig(newConfig) {
+        Object.assign(this.config, newConfig);
+    }
+    async getTasks(filter) {
+        const db = getDatabase(true);
+        try {
+            let whereClause = "t.dateCompleted IS NULL";
+            if (filter === "flagged") {
+                whereClause += " AND t.flagged = 1";
+            }
+            else if (filter === "due_today") {
+                // '+31 years' converts Core Data epoch (2001) to Unix epoch (1970)
+                whereClause += " AND date(t.dateDue, 'unixepoch', '+31 years') = date('now')";
+            }
+            else if (!filter || filter === "all") {
+                whereClause += " AND (t.flagged = 1 OR date(t.dateDue, 'unixepoch', '+31 years') <= date('now'))";
+            }
+            const query = `
+        SELECT
+          t.persistentIdentifier as id,
+          t.name,
+          t.plainTextNote as note,
+          t.flagged,
+          datetime(t.dateDue, 'unixepoch', '+31 years') as dueDate,
+          p.name as project
+        FROM Task t
+        LEFT JOIN ProjectInfo pi ON t.containingProjectInfo = pi.pk
+        LEFT JOIN Task p ON pi.task = p.persistentIdentifier
+        WHERE ${whereClause}
+        ORDER BY t.dateDue ASC, t.flagged DESC
+        LIMIT ${this.config.taskLimit}
+      `;
+            const rows = db.prepare(query).all();
+            return rows.map(row => ({
+                id: row.id,
+                name: row.name,
+                note: row.note || undefined,
+                flagged: row.flagged === 1,
+                dueDate: row.dueDate || undefined,
+                project: row.project || undefined,
+                completed: false
+            }));
+        }
+        finally {
+            db.close();
+        }
+    }
+    async createTask(input) {
+        const params = new URLSearchParams();
+        params.set("name", input.name);
+        params.set("autosave", "true");
+        if (input.note) {
+            params.set("note", input.note);
+        }
+        if (input.flagged) {
+            params.set("flag", "true");
+        }
+        if (input.dueDate) {
+            params.set("due", input.dueDate);
+        }
+        if (input.project) {
+            params.set("project", input.project);
+        }
+        const url = `omnifocus:///add?${params.toString()}`;
+        await execFileAsync("open", [url]);
+        return {
+            success: true,
+            warning: "Task created via URL scheme. It will sync automatically."
+        };
+    }
+    async updateTask(input) {
+        if (!this.config.directSqlAccess) {
+            return {
+                success: false,
+                warning: "Direct SQL access is disabled. Update operations require directSqlAccess=true or OmniFocus Pro. Use omnifocus_set_config to enable it."
+            };
+        }
+        const db = getDatabase(false);
+        try {
+            const updates = [];
+            const params = {
+                taskId: input.taskId
+            };
+            if (input.name !== undefined) {
+                updates.push("name = @name");
+                params.name = input.name;
+            }
+            if (input.note !== undefined) {
+                updates.push("plainTextNote = @note");
+                params.note = input.note;
+            }
+            if (input.flagged !== undefined) {
+                updates.push("flagged = @flagged");
+                params.flagged = input.flagged ? 1 : 0;
+            }
+            if (input.dueDate !== undefined) {
+                const date = new Date(input.dueDate);
+                const timestamp = (date.getTime() - CORE_DATA_EPOCH_MS) / 1000;
+                updates.push("dateDue = @dateDue");
+                params.dateDue = timestamp;
+            }
+            if (updates.length === 0) {
+                return { success: true };
+            }
+            const query = `UPDATE Task SET ${updates.join(", ")} WHERE persistentIdentifier = @taskId`;
+            const stmt = db.prepare(query);
+            const result = stmt.run(params);
+            if (result.changes === 0) {
+                throw new Error("Task not found");
+            }
+            return {
+                success: true,
+                warning: "Task updated via SQLite. Changes won't sync until OmniFocus is restarted. Consider using OmniFocus Pro for full sync support."
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    async completeTask(taskId) {
+        if (!this.config.directSqlAccess) {
+            return {
+                success: false,
+                warning: "Direct SQL access is disabled. Complete operations require directSqlAccess=true or OmniFocus Pro. Use omnifocus_set_config to enable it."
+            };
+        }
+        const db = getDatabase(false);
+        try {
+            const now = new Date();
+            const timestamp = (now.getTime() - CORE_DATA_EPOCH_MS) / 1000;
+            const stmt = db.prepare("UPDATE Task SET dateCompleted = @timestamp WHERE persistentIdentifier = @taskId");
+            const result = stmt.run({ timestamp, taskId });
+            if (result.changes === 0) {
+                throw new Error("Task not found");
+            }
+            return {
+                success: true,
+                warning: "Task marked complete via SQLite. Changes won't sync until OmniFocus is restarted. Consider using OmniFocus Pro for full sync support."
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    async getProjects() {
+        const db = getDatabase(true);
+        try {
+            const query = `
+        SELECT t.name
+        FROM Task t
+        JOIN ProjectInfo pi ON t.persistentIdentifier = pi.task
+        WHERE t.dateCompleted IS NULL
+        ORDER BY t.name
+      `;
+            const rows = db.prepare(query).all();
+            return rows.map(row => row.name);
+        }
+        finally {
+            db.close();
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+export interface OmniFocusTask {
+    id: string;
+    name: string;
+    note?: string;
+    project?: string;
+    flagged?: boolean;
+    dueDate?: string;
+    completed?: boolean;
+}
+export interface CreateTaskInput {
+    name: string;
+    note?: string;
+    project?: string;
+    flagged?: boolean;
+    dueDate?: string;
+}
+export interface UpdateTaskInput {
+    taskId: string;
+    name?: string;
+    note?: string;
+    flagged?: boolean;
+    dueDate?: string;
+}
+export interface GetTasksInput {
+    filter?: "flagged" | "due_today" | "all";
+}
+export interface CompleteTaskInput {
+    taskId: string;
+}
+export type OmniFocusVersion = "pro" | "standard";
+export interface OmniFocusConfig {
+    directSqlAccess: boolean;
+    taskLimit: number;
+}
+export declare const DEFAULT_TASK_LIMIT = 500;
+export interface OmniFocusProvider {
+    config: OmniFocusConfig;
+    setConfig(config: Partial<OmniFocusConfig>): void;
+    version: OmniFocusVersion;
+    getTasks(filter?: "flagged" | "due_today" | "all"): Promise<OmniFocusTask[]>;
+    createTask(input: CreateTaskInput): Promise<{
+        success: boolean;
+        taskId?: string;
+        warning?: string;
+    }>;
+    updateTask(input: UpdateTaskInput): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    completeTask(taskId: string): Promise<{
+        success: boolean;
+        warning?: string;
+    }>;
+    getProjects(): Promise<string[]>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const DEFAULT_TASK_LIMIT = 500;

package/dist/validation.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const CreateTaskInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    flagged: z.ZodOptional<z.ZodBoolean>;
+    dueDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    flagged?: boolean | undefined;
+    note?: string | undefined;
+    dueDate?: string | undefined;
+    project?: string | undefined;
+}, {
+    name: string;
+    flagged?: boolean | undefined;
+    note?: string | undefined;
+    dueDate?: string | undefined;
+    project?: string | undefined;
+}>;
+export declare const UpdateTaskInputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    flagged: z.ZodOptional<z.ZodBoolean>;
+    dueDate: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    flagged?: boolean | undefined;
+    name?: string | undefined;
+    note?: string | undefined;
+    dueDate?: string | undefined;
+}, {
+    taskId: string;
+    flagged?: boolean | undefined;
+    name?: string | undefined;
+    note?: string | undefined;
+    dueDate?: string | undefined;
+}>;
+export declare const CompleteTaskInputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+export declare const GetTasksInputSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodEnum<["flagged", "due_today", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    filter?: "flagged" | "due_today" | "all" | undefined;
+}, {
+    filter?: "flagged" | "due_today" | "all" | undefined;
+}>;
+export declare const SetConfigInputSchema: z.ZodObject<{
+    directSqlAccess: z.ZodOptional<z.ZodBoolean>;
+    taskLimit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    directSqlAccess?: boolean | undefined;
+    taskLimit?: number | undefined;
+}, {
+    directSqlAccess?: boolean | undefined;
+    taskLimit?: number | undefined;
+}>;
+export type ValidatedCreateTaskInput = z.infer<typeof CreateTaskInputSchema>;
+export type ValidatedUpdateTaskInput = z.infer<typeof UpdateTaskInputSchema>;
+export type ValidatedCompleteTaskInput = z.infer<typeof CompleteTaskInputSchema>;
+export type ValidatedGetTasksInput = z.infer<typeof GetTasksInputSchema>;
+export type ValidatedSetConfigInput = z.infer<typeof SetConfigInputSchema>;

package/dist/validation.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+const MAX_NAME_LENGTH = 1000;
+const MAX_NOTE_LENGTH = 10000;
+const MAX_PROJECT_LENGTH = 500;
+const MAX_TASK_ID_LENGTH = 100;
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const dateSchema = z.string().regex(ISO_DATE_REGEX, "Invalid date format. Use YYYY-MM-DD").refine((val) => {
+    const date = new Date(val);
+    return !isNaN(date.getTime());
+}, { message: "Invalid date value" });
+const taskIdSchema = z.string()
+    .min(1, "Task ID is required")
+    .max(MAX_TASK_ID_LENGTH, `Task ID must be at most ${MAX_TASK_ID_LENGTH} characters`)
+    .regex(/^[a-zA-Z0-9_-]+$/, "Task ID contains invalid characters");
+export const CreateTaskInputSchema = z.object({
+    name: z.string()
+        .min(1, "Task name is required")
+        .max(MAX_NAME_LENGTH, `Task name must be at most ${MAX_NAME_LENGTH} characters`),
+    note: z.string()
+        .max(MAX_NOTE_LENGTH, `Note must be at most ${MAX_NOTE_LENGTH} characters`)
+        .optional(),
+    project: z.string()
+        .max(MAX_PROJECT_LENGTH, `Project name must be at most ${MAX_PROJECT_LENGTH} characters`)
+        .optional(),
+    flagged: z.boolean().optional(),
+    dueDate: dateSchema.optional(),
+});
+export const UpdateTaskInputSchema = z.object({
+    taskId: taskIdSchema,
+    name: z.string()
+        .min(1, "Task name cannot be empty")
+        .max(MAX_NAME_LENGTH, `Task name must be at most ${MAX_NAME_LENGTH} characters`)
+        .optional(),
+    note: z.string()
+        .max(MAX_NOTE_LENGTH, `Note must be at most ${MAX_NOTE_LENGTH} characters`)
+        .optional(),
+    flagged: z.boolean().optional(),
+    dueDate: dateSchema.optional(),
+});
+export const CompleteTaskInputSchema = z.object({
+    taskId: taskIdSchema,
+});
+export const GetTasksInputSchema = z.object({
+    filter: z.enum(["flagged", "due_today", "all"]).optional(),
+});
+export const SetConfigInputSchema = z.object({
+    directSqlAccess: z.boolean().optional(),
+    taskLimit: z.number().int().min(1).max(10000).optional(),
+});

package/dist/version-detector.d.ts

@@ -0,0 +1,2 @@
+export type OmniFocusVersion = "pro" | "standard";
+export declare function detectVersion(): Promise<OmniFocusVersion>;

package/dist/version-detector.js

@@ -0,0 +1,47 @@
+import { spawn } from "child_process";
+function runAppleScriptCheck(script) {
+    return new Promise((resolve) => {
+        const child = spawn("osascript", ["-"], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stderr = "";
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ success: code === 0, stderr });
+        });
+        child.on("error", () => {
+            resolve({ success: false, stderr: "spawn error" });
+        });
+        child.stdin.write(script);
+        child.stdin.end();
+    });
+}
+const VERSION_DETECTION_TIMEOUT_MS = 5000;
+async function detectVersionInternal() {
+    const script = 'tell application "OmniFocus" to get name of first flattened task';
+    const result = await runAppleScriptCheck(script);
+    if (result.success) {
+        return "pro";
+    }
+    // error -1743 = scripting not authorized (Standard version)
+    if (result.stderr.includes("-1743")) {
+        return "standard";
+    }
+    // if no tasks exist, AppleScript still works - it's Pro
+    if (result.stderr.includes("Can't get")) {
+        return "pro";
+    }
+    // default to standard if we can't determine
+    return "standard";
+}
+export async function detectVersion() {
+    const timeout = new Promise((resolve) => {
+        setTimeout(() => {
+            console.error("[mcp-omnifocus] Version detection timed out, falling back to standard");
+            resolve("standard");
+        }, VERSION_DETECTION_TIMEOUT_MS);
+    });
+    return Promise.race([detectVersionInternal(), timeout]);
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "mcp-omnifocus",
+  "version": "0.1.0",
+  "description": "MCP server for OmniFocus with auto-detection of Pro/Standard version",
+  "author": "Mikhail Lihachev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/avlihachev/mcp-omnifocus"
+  },
+  "keywords": [
+    "mcp",
+    "omnifocus",
+    "claude",
+    "anthropic",
+    "productivity",
+    "task-management"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-omnifocus": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.17",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.17"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}