@iflow-mcp/omnifocus-mcp 1.2.3

package/dist/tools/primitives/addOmniFocusTask.js

@@ -0,0 +1,227 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { createDateOutsideTellBlock } from '../../utils/dateFormatting.js';
+const execAsync = promisify(exec);
+/**
+ * Generate pure AppleScript for task creation
+ */
+function generateAppleScript(params) {
+    // Sanitize and prepare parameters for AppleScript
+    const name = params.name.replace(/['"\\]/g, '\\$&'); // Escape quotes and backslashes
+    const note = params.note?.replace(/['"\\]/g, '\\$&') || '';
+    const dueDate = params.dueDate || '';
+    const deferDate = params.deferDate || '';
+    const flagged = params.flagged === true;
+    const estimatedMinutes = params.estimatedMinutes?.toString() || '';
+    const tags = params.tags || [];
+    const projectName = params.projectName?.replace(/['"\\]/g, '\\$&') || '';
+    const parentTaskId = params.parentTaskId?.replace(/['"\\]/g, '\\$&') || '';
+    const parentTaskName = params.parentTaskName?.replace(/['"\\]/g, '\\$&') || '';
+    // Generate date constructions outside tell blocks
+    let datePreScript = '';
+    let dueDateVar = '';
+    let deferDateVar = '';
+    if (dueDate) {
+        dueDateVar = `dueDate${Math.random().toString(36).substr(2, 9)}`;
+        datePreScript += createDateOutsideTellBlock(dueDate, dueDateVar) + '\n\n';
+    }
+    if (deferDate) {
+        deferDateVar = `deferDate${Math.random().toString(36).substr(2, 9)}`;
+        datePreScript += createDateOutsideTellBlock(deferDate, deferDateVar) + '\n\n';
+    }
+    // Construct AppleScript with error handling
+    let script = datePreScript + `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Resolve parent task if provided
+        set newTask to missing value
+        set parentTask to missing value
+        set placement to ""
+
+        if "${parentTaskId}" is not "" then
+          try
+            set parentTask to first flattened task where id = "${parentTaskId}"
+          end try
+          if parentTask is missing value then
+            try
+              set parentTask to first inbox task where id = "${parentTaskId}"
+            end try
+          end if
+          -- If projectName provided, ensure parent is within that project
+          if parentTask is not missing value and "${projectName}" is not "" then
+            try
+              set pproj to containing project of parentTask
+              if pproj is missing value or name of pproj is not "${projectName}" then set parentTask to missing value
+            end try
+          end if
+        end if
+
+        if parentTask is missing value and "${parentTaskName}" is not "" then
+          if "${projectName}" is not "" then
+            -- Find by name but constrain to the specified project
+            try
+              set parentTask to first flattened task where name = "${parentTaskName}"
+            end try
+            if parentTask is not missing value then
+              try
+                set pproj to containing project of parentTask
+                if pproj is missing value or name of pproj is not "${projectName}" then set parentTask to missing value
+              end try
+            end if
+          else
+            -- No project specified; allow global or inbox match by name
+            try
+              set parentTask to first flattened task where name = "${parentTaskName}"
+            end try
+            if parentTask is missing value then
+              try
+                set parentTask to first inbox task where name = "${parentTaskName}"
+              end try
+            end if
+          end if
+        end if
+
+        if parentTask is not missing value then
+          -- Create task under parent task
+          set newTask to make new task with properties {name:"${name}"} at end of tasks of parentTask
+        else if "${projectName}" is not "" then
+          -- Create under specified project
+          try
+            set theProject to first flattened project where name = "${projectName}"
+            set newTask to make new task with properties {name:"${name}"} at end of tasks of theProject
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Project not found: ${projectName}\\\"}"
+          end try
+        else
+          -- Fallback to inbox
+          set newTask to make new inbox task with properties {name:"${name}"}
+        end if
+        
+        -- Set task properties
+        ${note ? `set note of newTask to "${note}"` : ''}
+        ${dueDate ? `
+          -- Set due date
+          set due date of newTask to ` + dueDateVar : ''}
+        ${deferDate ? `
+          -- Set defer date
+          set defer date of newTask to ` + deferDateVar : ''}
+        ${flagged ? `set flagged of newTask to true` : ''}
+        ${estimatedMinutes ? `set estimated minutes of newTask to ${estimatedMinutes}` : ''}
+        
+        -- Derive placement from container; distinguish real parent vs project root task
+        try
+          set placement to "inbox"
+          set ctr to container of newTask
+          set cclass to class of ctr as string
+          set ctrId to id of ctr as string
+          if cclass is "project" then
+            set placement to "project"
+          else if cclass is "task" then
+            if parentTask is not missing value then
+              set parentId to id of parentTask as string
+              if ctrId is equal to parentId then
+                set placement to "parent"
+              else
+                -- Likely the project's root task; treat as project
+                set placement to "project"
+              end if
+            else
+              -- No explicit parent requested; container is root task -> treat as project
+              set placement to "project"
+            end if
+          else
+            set placement to "inbox"
+          end if
+        on error
+          -- If container access fails (e.g., inbox), default based on projectName
+          if "${projectName}" is not "" then
+            set placement to "project"
+          else
+            set placement to "inbox"
+          end if
+        end try
+
+        -- Get the task ID
+        set taskId to id of newTask as string
+        
+        -- Add tags if provided
+        ${tags.length > 0 ? tags.map(tag => {
+        const sanitizedTag = tag.replace(/['"\\]/g, '\\$&');
+        return `
+          try
+            set theTag to first flattened tag where name = "${sanitizedTag}"
+            add theTag to tags of newTask
+          on error
+            -- Tag might not exist, try to create it
+            try
+              set theTag to make new tag with properties {name:"${sanitizedTag}"}
+              add theTag to tags of newTask
+            on error
+              -- Could not create or add tag
+            end try
+          end try`;
+    }).join('\n') : ''}
+        
+        -- Return success with task ID and placement
+        return "{\\\"success\\\":true,\\\"taskId\\\":\\"" & taskId & "\\",\\\"name\\\":\\"${name}\\\",\\\"placement\\\":\\"" & placement & "\\"}"
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+    return script;
+}
+/**
+ * Add a task to OmniFocus
+ */
+export async function addOmniFocusTask(params) {
+    try {
+        // Generate AppleScript
+        const script = generateAppleScript(params);
+        console.error("Executing AppleScript via temp file...");
+        // Write to a temporary AppleScript file to avoid shell escaping issues
+        const tempFile = join(tmpdir(), `omnifocus_add_${Date.now()}.applescript`);
+        writeFileSync(tempFile, script, { encoding: 'utf8' });
+        // Execute AppleScript from file
+        const { stdout, stderr } = await execAsync(`osascript ${tempFile}`);
+        if (stderr) {
+            console.error("AppleScript stderr:", stderr);
+        }
+        console.error("AppleScript stdout:", stdout);
+        // Cleanup temp file
+        try {
+            unlinkSync(tempFile);
+        }
+        catch { }
+        // Parse the result
+        try {
+            const result = JSON.parse(stdout);
+            // Return the result
+            return {
+                success: result.success,
+                taskId: result.taskId,
+                error: result.error,
+                placement: result.placement
+            };
+        }
+        catch (parseError) {
+            console.error("Error parsing AppleScript result:", parseError);
+            return {
+                success: false,
+                error: `Failed to parse result: ${stdout}`
+            };
+        }
+    }
+    catch (error) {
+        console.error("Error in addOmniFocusTask:", error);
+        return {
+            success: false,
+            error: error?.message || "Unknown error in addOmniFocusTask"
+        };
+    }
+}

package/dist/tools/primitives/addProject.js

@@ -0,0 +1,132 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { createDateOutsideTellBlock } from '../../utils/dateFormatting.js';
+const execAsync = promisify(exec);
+/**
+ * Generate pure AppleScript for project creation
+ */
+function generateAppleScript(params) {
+    // Sanitize and prepare parameters for AppleScript
+    const name = params.name.replace(/['"\\]/g, '\\$&'); // Escape quotes and backslashes
+    const note = params.note?.replace(/['"\\]/g, '\\$&') || '';
+    const dueDate = params.dueDate || '';
+    const deferDate = params.deferDate || '';
+    const flagged = params.flagged === true;
+    const estimatedMinutes = params.estimatedMinutes?.toString() || '';
+    const tags = params.tags || [];
+    const folderName = params.folderName?.replace(/['"\\]/g, '\\$&') || '';
+    const sequential = params.sequential === true;
+    // Generate date constructions outside tell blocks
+    let datePreScript = '';
+    let dueDateVar = '';
+    let deferDateVar = '';
+    if (dueDate) {
+        dueDateVar = `dueDate${Math.random().toString(36).substr(2, 9)}`;
+        datePreScript += createDateOutsideTellBlock(dueDate, dueDateVar) + '\n\n';
+    }
+    if (deferDate) {
+        deferDateVar = `deferDate${Math.random().toString(36).substr(2, 9)}`;
+        datePreScript += createDateOutsideTellBlock(deferDate, deferDateVar) + '\n\n';
+    }
+    // Construct AppleScript with error handling
+    let script = datePreScript + `
+  try
+    tell application "OmniFocus"
+      tell front document
+        -- Determine the container (root or folder)
+        if "${folderName}" is "" then
+          -- Create project at the root level
+          set newProject to make new project with properties {name:"${name}"}
+        else
+          -- Use specified folder
+          try
+            set theFolder to first flattened folder where name = "${folderName}"
+            set newProject to make new project with properties {name:"${name}"} at end of projects of theFolder
+          on error
+            return "{\\\"success\\\":false,\\\"error\\\":\\\"Folder not found: ${folderName}\\\"}"
+          end try
+        end if
+        
+        -- Set project properties
+        ${note ? `set note of newProject to "${note}"` : ''}
+        ${dueDate ? `
+          -- Set due date
+          set due date of newProject to ` + dueDateVar : ''}
+        ${deferDate ? `
+          -- Set defer date
+          set defer date of newProject to ` + deferDateVar : ''}
+        ${flagged ? `set flagged of newProject to true` : ''}
+        ${estimatedMinutes ? `set estimated minutes of newProject to ${estimatedMinutes}` : ''}
+        ${`set sequential of newProject to ${sequential}`}
+        
+        -- Get the project ID
+        set projectId to id of newProject as string
+        
+        -- Add tags if provided
+        ${tags.length > 0 ? tags.map(tag => {
+        const sanitizedTag = tag.replace(/['"\\]/g, '\\$&');
+        return `
+          try
+            set theTag to first flattened tag where name = "${sanitizedTag}"
+            add theTag to tags of newProject
+          on error
+            -- Tag might not exist, try to create it
+            try
+              set theTag to make new tag with properties {name:"${sanitizedTag}"}
+              add theTag to tags of newProject
+            on error
+              -- Could not create or add tag
+            end try
+          end try`;
+    }).join('\n') : ''}
+        
+        -- Return success with project ID
+        return "{\\\"success\\\":true,\\\"projectId\\\":\\"" & projectId & "\\",\\\"name\\\":\\"${name}\\"}"
+      end tell
+    end tell
+  on error errorMessage
+    return "{\\\"success\\\":false,\\\"error\\\":\\"" & errorMessage & "\\"}"
+  end try
+  `;
+    return script;
+}
+/**
+ * Add a project to OmniFocus
+ */
+export async function addProject(params) {
+    try {
+        // Generate AppleScript
+        const script = generateAppleScript(params);
+        console.error("Executing AppleScript directly...");
+        // Execute AppleScript directly
+        const { stdout, stderr } = await execAsync(`osascript -e '${script}'`);
+        if (stderr) {
+            console.error("AppleScript stderr:", stderr);
+        }
+        console.error("AppleScript stdout:", stdout);
+        // Parse the result
+        try {
+            const result = JSON.parse(stdout);
+            // Return the result
+            return {
+                success: result.success,
+                projectId: result.projectId,
+                error: result.error
+            };
+        }
+        catch (parseError) {
+            console.error("Error parsing AppleScript result:", parseError);
+            return {
+                success: false,
+                error: `Failed to parse result: ${stdout}`
+            };
+        }
+    }
+    catch (error) {
+        console.error("Error in addProject:", error);
+        return {
+            success: false,
+            error: error?.message || "Unknown error in addProject"
+        };
+    }
+}

package/dist/tools/primitives/batchAddItems.js

@@ -0,0 +1,166 @@
+import { addOmniFocusTask } from './addOmniFocusTask.js';
+import { addProject } from './addProject.js';
+/**
+ * Add multiple items (tasks or projects) to OmniFocus
+ */
+export async function batchAddItems(items) {
+    try {
+        const results = new Array(items.length);
+        const processed = new Array(items.length).fill(false);
+        const tempToRealId = new Map();
+        // Pre-validate cycles in tempId -> parentTempId references
+        const tempIndex = new Map();
+        items.forEach((it, idx) => { if (it.tempId)
+            tempIndex.set(it.tempId, idx); });
+        // Detect cycles using DFS and capture cycle paths
+        const visiting = new Set();
+        const visited = new Set();
+        const inCycle = new Set();
+        const cycleMessageByTempId = new Map();
+        const stack = [];
+        function dfs(tempId) {
+            if (visited.has(tempId) || inCycle.has(tempId))
+                return;
+            if (visiting.has(tempId))
+                return; // already on stack, handled by caller
+            visiting.add(tempId);
+            stack.push(tempId);
+            const idx = tempIndex.get(tempId);
+            const parentTemp = items[idx].parentTempId;
+            if (parentTemp && tempIndex.has(parentTemp)) {
+                if (visiting.has(parentTemp)) {
+                    // Found a cycle; construct path
+                    const startIdx = stack.indexOf(parentTemp);
+                    const cycleIds = stack.slice(startIdx).concat(parentTemp);
+                    const cycleNames = cycleIds.map(tid => {
+                        const i = tempIndex.get(tid);
+                        return items[i].name || tid;
+                    });
+                    const pathText = `${cycleNames.join(' -> ')}`;
+                    for (const tid of cycleIds) {
+                        inCycle.add(tid);
+                        cycleMessageByTempId.set(tid, `Cycle detected: ${pathText}`);
+                    }
+                }
+                else {
+                    dfs(parentTemp);
+                }
+            }
+            stack.pop();
+            visiting.delete(tempId);
+            visited.add(tempId);
+        }
+        for (const tid of tempIndex.keys())
+            dfs(tid);
+        // Mark items that participate in cycles as failed early
+        for (const tid of inCycle) {
+            const idx = tempIndex.get(tid);
+            const msg = cycleMessageByTempId.get(tid) || `Cycle detected involving tempId: ${tid}`;
+            results[idx] = { success: false, error: msg };
+            processed[idx] = true;
+        }
+        // Mark items with unknown parentTempId (and no explicit parentTaskId) as invalid early
+        items.forEach((it, idx) => {
+            if (processed[idx])
+                return;
+            if (it.parentTempId && !tempIndex.has(it.parentTempId) && !it.parentTaskId) {
+                results[idx] = { success: false, error: `Unknown parentTempId: ${it.parentTempId}` };
+                processed[idx] = true;
+            }
+        });
+        // Stable order: sort by hierarchyLevel (undefined -> 0), then original index
+        const indexed = items.map((it, idx) => ({ ...it, __index: idx }));
+        indexed.sort((a, b) => (a.hierarchyLevel ?? 0) - (b.hierarchyLevel ?? 0) || a.__index - b.__index);
+        let madeProgress = true;
+        while (processed.some(p => !p) && madeProgress) {
+            madeProgress = false;
+            for (const item of indexed) {
+                const i = item.__index;
+                if (processed[i])
+                    continue;
+                try {
+                    if (item.type === 'project') {
+                        const projectParams = {
+                            name: item.name,
+                            note: item.note,
+                            dueDate: item.dueDate,
+                            deferDate: item.deferDate,
+                            flagged: item.flagged,
+                            estimatedMinutes: item.estimatedMinutes,
+                            tags: item.tags,
+                            folderName: item.folderName,
+                            sequential: item.sequential
+                        };
+                        const projectResult = await addProject(projectParams);
+                        results[i] = {
+                            success: projectResult.success,
+                            id: projectResult.projectId,
+                            error: projectResult.error
+                        };
+                        processed[i] = true;
+                        madeProgress = true;
+                        continue;
+                    }
+                    // task
+                    let parentTaskId = item.parentTaskId;
+                    if (!parentTaskId && item.parentTempId) {
+                        parentTaskId = tempToRealId.get(item.parentTempId);
+                        if (!parentTaskId) {
+                            // Parent not created yet; skip this round
+                            continue;
+                        }
+                    }
+                    const taskParams = {
+                        name: item.name,
+                        note: item.note,
+                        dueDate: item.dueDate,
+                        deferDate: item.deferDate,
+                        flagged: item.flagged,
+                        estimatedMinutes: item.estimatedMinutes,
+                        tags: item.tags,
+                        projectName: item.projectName,
+                        parentTaskId,
+                        parentTaskName: item.parentTaskName,
+                        hierarchyLevel: item.hierarchyLevel
+                    };
+                    const taskResult = await addOmniFocusTask(taskParams);
+                    results[i] = {
+                        success: taskResult.success,
+                        id: taskResult.taskId,
+                        error: taskResult.error
+                    };
+                    if (item.tempId && taskResult.taskId && taskResult.success) {
+                        tempToRealId.set(item.tempId, taskResult.taskId);
+                    }
+                    processed[i] = true;
+                    madeProgress = true;
+                }
+                catch (itemError) {
+                    results[i] = {
+                        success: false,
+                        error: itemError?.message || 'Unknown error processing item'
+                    };
+                    processed[i] = true; // avoid infinite loop on thrown errors
+                    madeProgress = true;
+                }
+            }
+        }
+        // Any unprocessed due to dependencies/cycles -> fail with message
+        for (const item of indexed) {
+            const i = item.__index;
+            if (!processed[i]) {
+                const reason = item.parentTempId && !tempToRealId.has(item.parentTempId)
+                    ? `Unresolved parentTempId: ${item.parentTempId}`
+                    : 'Unresolved dependency or cycle';
+                results[i] = { success: false, error: reason };
+                processed[i] = true;
+            }
+        }
+        const overallSuccess = results.some(r => r?.success);
+        return { success: overallSuccess, results };
+    }
+    catch (error) {
+        console.error('Error in batchAddItems:', error);
+        return { success: false, results: [], error: error?.message || 'Unknown error in batchAddItems' };
+    }
+}

package/dist/tools/primitives/batchRemoveItems.js

@@ -0,0 +1,44 @@
+import { removeItem } from './removeItem.js';
+/**
+ * Remove multiple items (tasks or projects) from OmniFocus
+ */
+export async function batchRemoveItems(items) {
+    try {
+        // Results array to track individual operation outcomes
+        const results = [];
+        // Process each item in sequence
+        for (const item of items) {
+            try {
+                // Remove item
+                const itemResult = await removeItem(item);
+                results.push({
+                    success: itemResult.success,
+                    id: itemResult.id,
+                    name: itemResult.name,
+                    error: itemResult.error
+                });
+            }
+            catch (itemError) {
+                // Handle individual item errors
+                results.push({
+                    success: false,
+                    error: itemError.message || "Unknown error processing item"
+                });
+            }
+        }
+        // Determine overall success (true if at least one item was removed successfully)
+        const overallSuccess = results.some(result => result.success);
+        return {
+            success: overallSuccess,
+            results: results
+        };
+    }
+    catch (error) {
+        console.error("Error in batchRemoveItems:", error);
+        return {
+            success: false,
+            results: [],
+            error: error.message || "Unknown error in batchRemoveItems"
+        };
+    }
+}