---
name: "Mojolicious::Commands"
section: "3pm"
platform: "linux"
package: "libmojolicious-perl"
version: "9.39+dfsg-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Mojolicious::Commands"
---

# Mojolicious::Commands(3pm)

Command line interface

## NAME

Mojolicious::Commands - Command line interface

## SYNOPSIS

```
  Usage: APPLICATION COMMAND [OPTIONS]
    mojo version
    mojo generate lite-app
    ./myapp.pl daemon -m production -l http://*:8080
    ./myapp.pl get /foo
    ./myapp.pl routes -v
  Tip: CGI and PSGI environments can be automatically detected very often and
       work without commands.
  Options (for all commands):
    -h, --help          Get more information on a specific command
        --home <path>   Path to home directory of your application, defaults to
                        the value of MOJO_HOME or auto-detection
    -m, --mode <name>   Operating mode for your application, defaults to the
                        value of MOJO_MODE/PLACK_ENV or "development"
```

## DESCRIPTION

Mojolicious::Commands is the interactive command line interface for the Mojolicious framework. It will automatically detect available commands in the `"Mojolicious::Command"` and `"Mojolicious::Command::Author"` namespaces.

## COMMANDS

These commands are available by default.

### cgi

```
  $ ./myapp.pl cgi
```

Use Mojolicious::Command::cgi to start application with CGI backend, usually auto detected.

### cpanify

```
  $ mojo cpanify -u sri -p secr3t Mojolicious-Plugin-Fun-0.1.tar.gz
```

Use Mojolicious::Command::Author::cpanify for uploading files to CPAN.

### daemon

```
  $ ./myapp.pl daemon
```

Use Mojolicious::Command::daemon to start application with standalone HTTP and WebSocket server.

### eval

```
  $ ./myapp.pl eval 'say app->home'
```

Use Mojolicious::Command::eval to run code against application.

### generate

```
  $ mojo generate
  $ mojo generate help
  $ ./myapp.pl generate help
```

List available generator commands with short descriptions.

```
  $ mojo generate help <generator>
  $ ./myapp.pl generate help <generator>
```

List available options for generator command with short descriptions.

### generate app

```
  $ mojo generate app <AppName>
```

Use Mojolicious::Command::Author::generate::app to generate application directory structure for a fully functional Mojolicious application.

### generate dockerfile

```
  $ ./myapp.pl generate dockerfile
  $ ./script/my_app generate dockerfile
```

Use Mojolicious::Command::Author::generate::dockerfile to generate `"Dockerfile"` for application.

### generate lite-app

```
  $ mojo generate lite-app
```

Use Mojolicious::Command::Author::generate::lite\_app to generate a fully functional Mojolicious::Lite application.

### generate makefile

```
  $ mojo generate makefile
  $ ./myapp.pl generate makefile
```

Use Mojolicious::Command::Author::generate::makefile to generate `"Makefile.PL"` file for application.

### generate plugin

```
  $ mojo generate plugin <PluginName>
```

Use Mojolicious::Command::Author::generate::plugin to generate directory structure for a fully functional Mojolicious plugin.

### get

```
  $ mojo get https://mojolicious.org
  $ ./myapp.pl get /foo
```

Use Mojolicious::Command::get to perform requests to remote host or local application.

### help

```
  $ mojo
  $ mojo help
  $ ./myapp.pl help
```

List available commands with short descriptions.

```
  $ mojo help <command>
  $ ./myapp.pl help <command>
```

List available options for the command with short descriptions.

### inflate

```
  $ ./myapp.pl inflate
```

Use Mojolicious::Command::Author::inflate to turn templates and static files embedded in the `"DATA"` sections of your application into real files.

### prefork

```
  $ ./myapp.pl prefork
```

Use Mojolicious::Command::prefork to start application with standalone pre-forking HTTP and WebSocket server.

### psgi

```
  $ ./myapp.pl psgi
```

Use Mojolicious::Command::psgi to start application with PSGI backend, usually auto detected.

### routes

```
  $ ./myapp.pl routes
```

Use Mojolicious::Command::routes to list application routes.

### version

```
  $ mojo version
  $ ./myapp.pl version
```

Use Mojolicious::Command::version to show version information for available core and optional modules, very useful for debugging.

## ATTRIBUTES

Mojolicious::Commands inherits all attributes from Mojolicious::Command and implements the following new ones.

### hint

```
  my $hint  = $commands->hint;
  $commands = $commands->hint('Foo');
```

Short hint shown after listing available commands.

### message

```
  my $msg   = $commands->message;
  $commands = $commands->message('Hello World!');
```

Short usage message shown before listing available commands.

### namespaces

```
  my $namespaces = $commands->namespaces;
  $commands      = $commands->namespaces(['MyApp::Command']);
```

Namespaces to load commands from, defaults to `"Mojolicious::Command::Author"` and `"Mojolicious::Command"`.

```
  # Add another namespace to load commands from
  push @{$commands->namespaces}, 'MyApp::Command';
```

## METHODS

Mojolicious::Commands inherits all methods from Mojolicious::Command and implements the following new ones.

### detect

```
  my $env = $commands->detect;
```

Try to detect environment, or return `"undef"` if none could be detected.

### run

```
  $commands->run;
  $commands->run(@ARGV);
```

Load and run commands. Automatic deployment environment detection can be disabled with the `"MOJO_NO_DETECT"` environment variable.

### start\_app

```
  Mojolicious::Commands->start_app('MyApp');
  Mojolicious::Commands->start_app(MyApp => @ARGV);
```

Load application from class and start the command line interface for it. Note that the options `"-h"`/`"--help"`, `"--home"` and `"-m"`/`"--mode"`, which are shared by all commands, will be parsed from `@ARGV` during compile time.

```
  # Always start daemon for application
  Mojolicious::Commands->start_app('MyApp', 'daemon', '-l', 'http://*:8080');
```

## SEE ALSO

Mojolicious, Mojolicious::Guides, \<https://mojolicious.org\>.