function Transport(context) {
  this._context = context;
  this._options = {
    silent: false,
    failsafe: false
  };
  this._execWith = '';

  this._logger = logger({
    debug: this._context.options.debug,
    prefix: this._context.remote.host
  });

  this.runtime = Object.freeze(extend({}, this._context.remote)); // userland

  commands.forEach(function(command) {
    this[command] = function(args, options) {
      if(typeof args === 'object') {
        options = args;
        args = null;
      }

      var _command = format('%s%s', this._execWith, command);
      _command = args ? format('%s %s', _command, args) : _command;

      return this._exec(_command, options || {});
    };
  }, this);
}
A transport is the interface you use during flights. Basically they
offer you a set of methods to execute a chain of commands. Depending on the
type of flight, this is either a `Shell` object for local
flights, or an `SSH` for remote flights. Both transports
expose the same set of methods as described in this section.

```javascript
plan.local(function(local) {
  local.echo('Shell.echo() called');
});

plan.remote(function(remote) {
  remote.echo('SSH.echo() called');
});
```

We call the Transport object `transport` in the following section to avoid
confusion. However, do yourself a favor and use `local` for local, and
`remote` for remote flights.

#### Accessing runtime information

Flightplan provides information during flights with the `runtime` properties:

```javascript
plan.remote(function(transport) { // applies to local flights as well
  // Flightplan specific information
  console.log(plan.runtime.task);    // 'default'
  console.log(plan.runtime.target);  // 'production'
  console.log(plan.runtime.hosts);   // [{ host: 'www1.example.com', port: 22 }, ...]
  console.log(plan.runtime.options); // { debug: true, ... }

  // Flight specific information
  console.log(transport.runtime); // { host: 'www1.example.com', port: 22 }
});
```

@class Transport
@return {Object} transport