What is a script?#

A script, in Composer's terms, can either be a PHP callback (defined as a static method) or any command-line executable command. Scripts are useful for executing a package's custom code or package-specific commands during the Composer execution process.

Note: Only scripts defined in the root package's composer.json are executed. If a dependency of the root package specifies its own scripts, Composer does not execute those additional scripts.

Event names#

Composer fires the following named events during its execution process:

Command Events#

Installer Events#

Package Events#

Plugin Events#

Note: Composer makes no assumptions about the state of your dependencies prior to install or update. Therefore, you should not specify scripts that require Composer-managed dependencies in the pre-update-cmd or pre-install-cmd event hooks. If you need to execute scripts prior to install or update please make sure they are self-contained within your root package.

Defining scripts#

The root JSON object in composer.json should have a property called "scripts", which contains pairs of named events and each event's corresponding scripts. An event's scripts can be defined as either as a string (only for a single script) or an array (for single or multiple scripts.)

For any given event:

Script definition example:

    "scripts": {
        "post-update-cmd": "MyVendor\\MyClass::postUpdate",
        "post-package-install": [
        "post-install-cmd": [
            "phpunit -c app/"
        "post-autoload-dump": [
        "post-create-project-cmd": [
            "php -r \"copy('config/local-example.php', 'config/local.php');\""

Using the previous definition example, here's the class MyVendor\MyClass that might be used to execute the PHP callbacks:


namespace MyVendor;

use Composer\Script\Event;
use Composer\Installer\PackageEvent;

class MyClass
    public static function postUpdate(Event $event)
        $composer = $event->getComposer();
        // do stuff

    public static function postAutoloadDump(Event $event)
        $vendorDir = $event->getComposer()->getConfig()->get('vendor-dir');
        require $vendorDir . '/autoload.php';


    public static function postPackageInstall(PackageEvent $event)
        $installedPackage = $event->getOperation()->getPackage();
        // do stuff

    public static function warmCache(Event $event)
        // make cache toasty

When an event is fired, your PHP callback receives as first argument an Composer\EventDispatcher\Event object. This object has a getName() method that lets you retrieve event name.

Depending on the script types (see list above) you will get various event subclasses containing various getters with relevant data and associated objects:

Running scripts manually#

If you would like to run the scripts for an event manually, the syntax is:

composer run-script [--dev] [--no-dev] script

For example composer run-script post-install-cmd will run any post-install-cmd scripts that have been defined.

You can also give additional arguments to the script handler by appending -- followed by the handler arguments. e.g. composer run-script post-install-cmd -- --check will pass--check along to the script handler. Those arguments are received as CLI arg by CLI handlers, and can be retrieved as an array via $event->getArguments() by PHP handlers.

Writing custom commands#

If you add custom scripts that do not fit one of the predefined event name above, you can either run them with run-script or also run them as native Composer commands. For example the handler defined below is executable by simply running composer test:

    "scripts": {
        "test": "phpunit"

Note: Composer's bin-dir is pushed on top of the PATH so that binaries of dependencies are easily accessible as CLI commands when writing scripts.

Found a typo? Something is wrong in this documentation? Just fork and edit it!