OmniFocus-MCP

Instructions

Implementation Reference

• src/tools/definitions/removeItem.ts:11-86 (handler)

  MCP tool handler for 'remove_item': validates arguments, calls primitive removeItem, handles success/error responses.

  export async function handler(args: z.infer<typeof schema>, extra: RequestHandlerExtra) {
    try {
      // Validate that either id or name is provided
      if (!args.id && !args.name) {
        return {
          content: [{
            type: "text" as const,
            text: "Either id or name must be provided to remove an item."
          }],
          isError: true
        };
      }
      
      // Validate itemType
      if (!['task', 'project'].includes(args.itemType)) {
        return {
          content: [{
            type: "text" as const,
            text: `Invalid item type: ${args.itemType}. Must be either 'task' or 'project'.`
          }],
          isError: true
        };
      }
      
      // Log the remove operation for debugging
      console.error(`Removing ${args.itemType} with ID: ${args.id || 'not provided'}, Name: ${args.name || 'not provided'}`);
      
      // Call the removeItem function 
      const result = await removeItem(args as RemoveItemParams);
      
      if (result.success) {
        // Item was removed successfully
        const itemTypeLabel = args.itemType === 'task' ? 'Task' : 'Project';
        
        return {
          content: [{
            type: "text" as const,
            text: `✅ ${itemTypeLabel} "${result.name}" removed successfully.`
          }]
        };
      } else {
        // Item removal failed
        let errorMsg = `Failed to remove ${args.itemType}`;
        
        if (result.error) {
          if (result.error.includes("Item not found")) {
            errorMsg = `${args.itemType.charAt(0).toUpperCase() + args.itemType.slice(1)} not found`;
            if (args.id) errorMsg += ` with ID "${args.id}"`;
            if (args.name) errorMsg += `${args.id ? ' or' : ' with'} name "${args.name}"`;
            errorMsg += '.';
          } else {
            errorMsg += `: ${result.error}`;
          }
        }
        
        return {
          content: [{
            type: "text" as const,
            text: errorMsg
          }],
          isError: true
        };
      }
    } catch (err: unknown) {
      const error = err as Error;
      console.error(`Tool execution error: ${error.message}`);
      
      return {
        content: [{
          type: "text" as const,
          text: `Error removing ${args.itemType}: ${error.message}`
        }],
        isError: true
      };
    }
  } 

• src/tools/definitions/removeItem.ts:5-9 (schema)

  Zod schema defining input parameters for the remove_item tool.

  export const schema = z.object({
    id: z.string().optional().describe("The ID of the task or project to remove"),
    name: z.string().optional().describe("The name of the task or project to remove (as fallback if ID not provided)"),
    itemType: z.enum(['task', 'project']).describe("Type of item to remove ('task' or 'project')")
  });

• src/server.ts:46-51 (registration)

  Registration of the 'remove_item' tool on the MCP server.

  server.tool(
    "remove_item",
    "Remove a task or project from OmniFocus",
    removeItemTool.schema.shape,
    removeItemTool.handler
  );

• src/tools/primitives/removeItem.ts:143-195 (helper)

  Core helper function implementing item removal via dynamically generated AppleScript executed with osascript.

  export async function removeItem(params: RemoveItemParams): Promise<{success: boolean, id?: string, name?: string, error?: string}> {
    try {
      // Generate AppleScript
      const script = generateAppleScript(params);
      
      console.error("Executing AppleScript for removal...");
      console.error(`Item type: ${params.itemType}, ID: ${params.id || 'not provided'}, Name: ${params.name || 'not provided'}`);
      
      // Log a preview of the script for debugging (first few lines)
      const scriptPreview = script.split('\n').slice(0, 10).join('\n') + '\n...';
      console.error("AppleScript preview:\n", scriptPreview);
      
      // 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,
          id: result.id,
          name: result.name,
          error: result.error
        };
      } catch (parseError) {
        console.error("Error parsing AppleScript result:", parseError);
        return {
          success: false,
          error: `Failed to parse result: ${stdout}`
        };
      }
    } catch (error: any) {
      console.error("Error in removeItem execution:", error);
      
      // Include more detailed error information
      if (error.message && error.message.includes('syntax error')) {
        console.error("This appears to be an AppleScript syntax error. Review the script generation logic.");
      }
      
      return {
        success: false,
        error: error?.message || "Unknown error in removeItem"
      };
    }
  }