Error: EACCES: permission denied, mkdir '/path'
  • 11-Jun-2023
Lightrun Team
Author Lightrun Team
Error: EACCES: permission denied, mkdir '/path'

Error: EACCES: permission denied, mkdir ‘/path’

Lightrun Team
Lightrun Team

Explanation of the problem

When running the command timecut with specific parameters, I encountered an error in the terminal. The command is intended to capture a video from a given URL using the --selector option to specify an element to focus on, and --left, --right, --top, --bottom options to define the margins around the element. Additionally, the --duration option sets the length of the video, and the --output option specifies the output file path. However, during execution, the following error occurred:


[0922/] Lost UI shared context.


This error suggests that the GPU process encountered an issue with the shared context while executing the command. It could be related to GPU settings or resource availability. Further investigation is required to determine the exact cause of this error.

In addition to the GPU error, the terminal output also shows a permission denied error when attempting to create a directory specified by the --output option. The error message indicates that the process was unable to create the directory at the given path /path. Here are the relevant error details:


{ Error: EACCES: permission denied, mkdir '/path'
    at Object.fs.mkdirSync (fs.js:902:18)
    at makeFileDirectoryIfNeeded (/Users/m/.config/yarn/global/node_modules/timesnap/index.js:211:10)
    at /Users/m/.config/yarn/global/node_modules/timesnap/index.js:374:15

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for Error: EACCES: permission denied, mkdir ‘/path’

To resolve the encountered errors, there are several steps you can take.

  1. GPU Error (Lost UI shared context): The error message indicates a problem with the GPU process’s shared context. This issue may be related to GPU settings or resource availability. Here are a few potential solutions:
    • Update GPU Drivers: Ensure that you have the latest GPU drivers installed on your system. Visit the manufacturer’s website (e.g., NVIDIA, AMD, Intel) to download and install the latest drivers compatible with your GPU model.
    • Check GPU Resource Usage: Make sure that the GPU resources are not being heavily utilized by other processes or applications. Close unnecessary applications or processes that might be consuming GPU resources, which could be conflicting with the timecut command.
    • Verify GPU Compatibility: Confirm that your GPU supports the required features for the timecut command. Check the documentation or specifications of your GPU model to ensure it meets the necessary requirements for GPU-accelerated processes.
    • Disable GPU Acceleration: As a temporary workaround, you can try disabling GPU acceleration for the timecut command. This can be achieved by setting an environment variable to force software rendering. For example, on Linux or macOS, you can run:




    • Then, execute the timecut command again to see if the GPU error persists.

    If none of these steps resolve the GPU error, you may need to consult the documentation or seek support from the timecut project or relevant community forums for further assistance.

  1. Permission Denied Error (Creating Directory): The second error message indicates a permission denied error when attempting to create a directory specified by the --output option. To resolve this issue, consider the following steps:
    • Verify File System Permissions: Ensure that the user running the timecut command has the necessary permissions to create directories and write files in the specified path. Check the permissions of the target directory using the ls -l command (on Unix-based systems) to ensure the user has write access.
    • Use a Different Output Directory: If the original directory specified by the --output option is restricted due to permissions, you can try specifying a different directory where the user has write access. Update the --output option in the command to a directory path where you have the necessary permissions.
    • Run the Command with Sudo: If you have the appropriate privileges, you can run the timecut command with sudo to execute it with elevated permissions. However, exercise caution when using sudo, as it grants extensive system access. Use it only when necessary and ensure you understand the potential risks involved.

    By addressing the permission denied error and ensuring the correct permissions and accessible output directory, you should be able to resolve this issue.

If the above solutions do not resolve the problem, it is advisable to consult the documentation or seek support from the timecut project or community for further assistance. They may provide specific guidance or insights into the encountered errors and suggest additional troubleshooting steps.


Other popular problems with timecut

Error: FFmpeg not found or executable: This error occurs when timecut cannot locate the FFmpeg executable on the system. FFmpeg is a dependency of timecut and is required for video processing. To resolve this issue, you need to ensure that FFmpeg is installed and accessible. Here’s a possible solution:

  • Install FFmpeg: Use your package manager (e.g., apt, brew, yum) to install FFmpeg. For example, on Ubuntu, you can run the following command:


sudo apt install ffmpeg


    • After installing FFmpeg, verify its availability by running ffmpeg in the terminal. If it’s properly installed, you should see the FFmpeg command-line interface.
  1. Error: No input URL specified: This error occurs when the timecut command is missing the input URL or file path. The input URL or file specifies the source from which timecut extracts the video. To resolve this issue, make sure to provide a valid input URL or file path as an argument to the timecut command. Here’s an example of how to specify the input URL:


timecut --selector "iframe" --output /path/to/output/video.mp4


  1. In the above command, replace with the actual URL or file path of the video you want to process.
  2. Error: Invalid selector or element not found: This error occurs when the specified CSS selector in the --selector option does not match any elements on the webpage. The selector is used to identify the specific element within the webpage that contains the video to be cut. To resolve this issue, ensure that the CSS selector accurately targets the desired video element. Here’s an example of how to specify a CSS selector:


timecut --selector "#video-element" --output /path/to/output/video.mp4


  1. In the above command, #video-element represents the CSS selector targeting an element with the ID “video-element.” Adjust the selector according to the structure of the webpage and the HTML element that contains the video.

By addressing these common problems and following the provided solutions, you can overcome some of the typical challenges when working with timecut. However, it’s important to note that these solutions may not cover every possible scenario, and it’s recommended to refer to the timecut documentation, project resources, or community support for more specific troubleshooting guidance.

A brief introduction to timecut

timecut is a command-line tool used for cutting and extracting segments from videos based on specific time intervals. It utilizes FFmpeg, a popular multimedia framework, for video processing tasks. With timecut, users can define the start and end times of the desired video segments, allowing them to extract and save only the relevant portions of a video. This tool is particularly useful when working with large videos and wanting to extract specific segments for further analysis or presentation purposes.

To use timecut, users need to provide the input URL or file path of the video, specify the start and end times of the desired segments, and define the output location for the extracted video. Additionally, timecut supports the use of CSS selectors to target specific HTML elements containing embedded videos on web pages. This feature enables users to extract videos directly from websites by specifying the CSS selector that identifies the desired video element. By leveraging timecut‘s functionality, developers and researchers can efficiently extract and manipulate video segments, saving time and effort in video processing workflows.

Most popular use cases for timecut

  1. Video Segment Extraction: timecut can be used to extract specific segments from videos based on defined time intervals. By specifying the start and end times, users can extract the desired portions of a video, allowing for more targeted analysis or presentation of video content. The following code snippet demonstrates the usage of timecut to extract a 30-second segment starting at 1 minute into the video:


timecut --input /path/to/input/video.mp4 --start 01:00 --end 01:30 --output /path/to/output/segment.mp4


  1. Web Page Video Extraction: timecut supports the extraction of videos from web pages by utilizing CSS selectors. Users can specify the CSS selector that identifies the desired video element, and timecut will extract the video content from the corresponding web page. This feature is particularly useful for scenarios where videos are embedded within web pages, and users want to extract specific videos programmatically. The following example demonstrates the usage of timecut with a CSS selector to extract a video from a web page:


timecut --url --selector ".video-element" --start 00:10 --end 00:30 --output /path/to/output/segment.mp4


  1. Batch Processing: timecut can be employed for batch processing of multiple videos. Users can provide a list of input files or URLs along with their respective start and end times to extract multiple video segments in one execution. This capability is valuable when dealing with large collections of videos, as it allows for efficient extraction of specific segments from multiple sources. The following code snippet demonstrates the batch processing functionality of timecut:


timecut --input /path/to/input/videos.txt --output-dir /path/to/output/segments/ --batch


In this example, videos.txt is a text file containing the list of input videos and their corresponding start and end times. The extracted video segments will be saved in the specified output directory.



It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.