navy 7.0.0-alpha.2 → 7.0.0-alpha.4

package/lib/__tests__/http-proxy.js

@@ -62,6 +62,185 @@ describe('resolveProxyImage', function () {
     (0, _chai.expect)((0, _httpProxy.resolveProxyImage)()).to.equal('navycloud/navy-proxy');
   });
 });
+describe('resolveProxyEnvFromNavyFile', function () {
+  it('should return an empty object when no navyFile is provided', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)()).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(null)).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(undefined)).to.eql({});
+  });
+  it('should return an empty object when navyFile has no httpProxyEnv', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({})).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      plugins: []
+    })).to.eql({});
+  });
+  it('should return the httpProxyEnv map from navyFile', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        FOO: 'bar',
+        BAZ: 'qux'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      FOO: 'bar',
+      BAZ: 'qux'
+    });
+  });
+  it('should drop entries with empty string, null, or undefined values', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        EMPTY: '',
+        NULL: null,
+        UNDEF: undefined,
+        KEEP: 'value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      KEEP: 'value'
+    });
+  });
+  it('should coerce numeric values to strings', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        PORT: 8080,
+        ZERO: 0
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      PORT: '8080',
+      ZERO: '0'
+    });
+  });
+  it('should return an empty object when httpProxyEnv is a string', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      httpProxyEnv: 'FOO=bar'
+    })).to.eql({});
+  });
+  it('should return an empty object when httpProxyEnv is an array', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      httpProxyEnv: ['FOO=bar']
+    })).to.eql({});
+  });
+});
+describe('resolveProxyEnvAllowlist', function () {
+  const namesSetDuringTest = [];
+  function setEnv(name, value) {
+    namesSetDuringTest.push(name);
+    process.env[name] = value;
+  }
+  afterEach(function () {
+    delete process.env.NAVY_HTTP_PROXY_ENV;
+    while (namesSetDuringTest.length > 0) {
+      delete process.env[namesSetDuringTest.pop()];
+    }
+  });
+  it('should return an empty object when NAVY_HTTP_PROXY_ENV is unset', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({});
+  });
+  it('should return an empty object when NAVY_HTTP_PROXY_ENV is empty', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = '';
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({});
+  });
+  it('should forward a single name whose value is present in process.env', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FORWARD_ME';
+    setEnv('FORWARD_ME', 'hello');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FORWARD_ME: 'hello'
+    });
+  });
+  it('should trim whitespace from comma-separated names', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = '  FOO , BAR  ';
+    setEnv('FOO', 'one');
+    setEnv('BAR', 'two');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'one',
+      BAR: 'two'
+    });
+  });
+  it('should deduplicate repeated names', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FOO,FOO,BAR,FOO';
+    setEnv('FOO', 'one');
+    setEnv('BAR', 'two');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'one',
+      BAR: 'two'
+    });
+  });
+  it('should drop names whose value is empty or unset', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'PRESENT,EMPTY,MISSING';
+    setEnv('PRESENT', 'value');
+    setEnv('EMPTY', '');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      PRESENT: 'value'
+    });
+  });
+  it('should ignore empty entries produced by trailing or repeated commas', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = ',FOO,,';
+    setEnv('FOO', 'value');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'value'
+    });
+  });
+});
+describe('resolveProxyEnv', function () {
+  const namesSetDuringTest = [];
+  function setEnv(name, value) {
+    namesSetDuringTest.push(name);
+    process.env[name] = value;
+  }
+  afterEach(function () {
+    delete process.env.NAVY_HTTP_PROXY_ENV;
+    while (namesSetDuringTest.length > 0) {
+      delete process.env[namesSetDuringTest.pop()];
+    }
+  });
+  it('should return null when both sources are empty', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)()).to.equal(null);
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)({})).to.equal(null);
+  });
+  it('should return only the navyFile entries when no allowlist is set', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        FOO: 'bar'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      FOO: 'bar'
+    });
+  });
+  it('should return only the allowlisted entries when navyFile has none', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FORWARD_ME';
+    setEnv('FORWARD_ME', 'hello');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)()).to.eql({
+      FORWARD_ME: 'hello'
+    });
+  });
+  it('should merge entries from both sources', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FROM_ENV';
+    setEnv('FROM_ENV', 'env-value');
+    const navyFile = {
+      httpProxyEnv: {
+        FROM_FILE: 'file-value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      FROM_FILE: 'file-value',
+      FROM_ENV: 'env-value'
+    });
+  });
+  it('should give the allowlist precedence on key collisions', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'SHARED';
+    setEnv('SHARED', 'env-value');
+    const navyFile = {
+      httpProxyEnv: {
+        SHARED: 'file-value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      SHARED: 'env-value'
+    });
+  });
+});
 describe('resolveDockerSocketPath', function () {
   let originalDockerHost;
   beforeEach(function () {
@@ -211,4 +390,35 @@ describe('reconfigureHTTPProxy', function () {
     const rmCall = execStub.getCalls().find(c => Array.isArray(c.args[1]) && c.args[1].includes('rm'));
     (0, _chai.expect)(rmCall).to.equal(undefined);
   });
+  it('should omit the environment block from the proxy compose service when no env config is provided', async function () {
+    listNetworksStub.resolves([]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: []
+    });
+    const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+    (0, _chai.expect)(written.services['nginx-proxy']).to.not.have.property('environment');
+  });
+  it('should include the merged environment block on the proxy compose service when httpProxyEnv or NAVY_HTTP_PROXY_ENV is set', async function () {
+    listNetworksStub.resolves([]);
+    process.env.NAVY_HTTP_PROXY_ENV = 'FROM_ENV';
+    process.env.FROM_ENV = 'env-value';
+    try {
+      await (0, _httpProxy.reconfigureHTTPProxy)({
+        navies: [],
+        navyFile: {
+          httpProxyEnv: {
+            FROM_FILE: 'file-value'
+          }
+        }
+      });
+      const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+      (0, _chai.expect)(written.services['nginx-proxy'].environment).to.eql({
+        FROM_FILE: 'file-value',
+        FROM_ENV: 'env-value'
+      });
+    } finally {
+      delete process.env.NAVY_HTTP_PROXY_ENV;
+      delete process.env.FROM_ENV;
+    }
+  });
 });

package/lib/cli/__tests__/program-unknown-options.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _chai = require("chai");
+var _commander = require("commander");
+/* eslint-env mocha */
+
+/**
+ * These tests check that the commander configuration the navy CLI relies on
+ * (positional options + per-subcommand option declarations) rejects options
+ * that a subcommand does not declare, using the exact error format commander
+ * emits by default.
+ *
+ * We build a minimal program with the same shape as packages/navy/src/cli/program.js
+ * rather than loading that module, because importing program.js has side effects
+ * (config reading, action wiring) that are not relevant to argument parsing.
+ */
+describe('cli/program unknown option handling', function () {
+  function buildProgram() {
+    const program = new _commander.Command();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: () => {}
+    });
+    program.enablePositionalOptions();
+    program.option('-e, --navy [env]', 'set the navy name to be used', 'dev');
+    program.command('status').option('--json', 'output JSON instead of a table').action(() => {});
+    program.command('start [services...]').option('-e, --navy [env]', 'set the navy name to be used', 'dev').action(() => {});
+    return program;
+  }
+  describe('a subcommand that does not declare the option', function () {
+    it('should throw a commander error for an unknown short option', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'status', '-e', 'foo'])).to.throw(/unknown option '-e'/);
+    });
+    it('should produce a non-zero exit code on the thrown error', function () {
+      const program = buildProgram();
+      try {
+        program.parse(['node', 'navy', 'status', '-e', 'foo']);
+        _chai.expect.fail('expected parse to throw');
+      } catch (ex) {
+        (0, _chai.expect)(ex.exitCode).to.be.greaterThan(0);
+      }
+    });
+    it('should emit the canonical commander unknown-option message', function () {
+      const program = buildProgram();
+      try {
+        program.parse(['node', 'navy', 'status', '-e', 'foo']);
+        _chai.expect.fail('expected parse to throw');
+      } catch (ex) {
+        (0, _chai.expect)(ex.message).to.equal("error: unknown option '-e'");
+      }
+    });
+    it('should still accept declared options on the same subcommand', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'status', '--json'])).to.not.throw();
+    });
+  });
+  describe('a subcommand that declares the option', function () {
+    it('should accept the option after the subcommand name', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'start', '-e', 'foo'])).to.not.throw();
+    });
+    it('should accept the option before the subcommand name (parent inherits)', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', '-e', 'foo', 'start'])).to.not.throw();
+    });
+  });
+});

package/lib/cli/__tests__/program.js

@@ -28,6 +28,7 @@ describe('cli/program', function () {
     helpHandlersByCommand = {};
     fakeProgram = {
       option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {
@@ -155,6 +156,10 @@ describe('cli/program', function () {
       loadModule();
       (0, _chai.expect)(fakeProgram.option.calledWith('-e, --navy [env]', _sinon.default.match.string, 'dev')).to.equal(true);
     });
+    it('should enable positional options so unknown subcommand options are rejected', function () {
+      loadModule();
+      (0, _chai.expect)(fakeProgram.enablePositionalOptions.calledOnce).to.equal(true);
+    });
   });
   describe('lazyRequire wrapped action', function () {
     it('should pass through arguments to the underlying module', async function () {
@@ -324,6 +329,103 @@ describe('cli/program', function () {
     // exercised in practice. We do not test it because asserting that
     // behaviour would lock in a latent bug.
   });
+  describe('normaliseLazyRequireArgs (via lazyRequire wrapped action)', function () {
+    let importSpy;
+    function loadWithImportSpy() {
+      importSpy = sandbox.stub().resolves('imported');
+      return _proxyquire.default.noCallThru()('../program', {
+        commander: {
+          program: createCapturingProgram()
+        },
+        '../errors': {
+          NavyError: _errors.NavyError
+        },
+        '../config': {
+          getConfig: getConfigStub
+        },
+        '../driver-logging': {
+          startDriverLogging: startDriverLoggingStub,
+          stopDriverLogging: stopDriverLoggingStub
+        },
+        '../config-provider': {
+          getImportCommandLineOptions: getImportCommandLineOptionsStub
+        },
+        '../navy': {
+          getNavy: getNavyStub
+        },
+        './import': importSpy,
+        './launch': () => Promise.resolve(),
+        './ps': () => Promise.resolve(),
+        './updates': () => Promise.resolve(),
+        './logs': () => Promise.resolve(),
+        './health': () => Promise.resolve(),
+        './wait-for-healthy': () => Promise.resolve(),
+        './https': () => Promise.resolve(),
+        './open': () => Promise.resolve(),
+        './develop': () => Promise.resolve(),
+        './live': () => Promise.resolve(),
+        './run': () => Promise.resolve(),
+        './refresh-config': () => Promise.resolve(),
+        './status': () => Promise.resolve(),
+        './doctor': () => Promise.resolve(),
+        './config/wrapper': () => Promise.resolve(),
+        './external-ip': () => Promise.resolve(),
+        './lan-ip': () => Promise.resolve(),
+        './local-ip': () => Promise.resolve()
+      });
+    }
+    it('should pass through unchanged when invoked with no arguments at all', async function () {
+      loadWithImportSpy();
+      capturedActions.import();
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([]);
+    });
+    it('should strip the trailing Command instance when no other args were supplied', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'global'
+        })
+      };
+      capturedActions.import(fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([]);
+    });
+    it('should merge inherited globals into the trailing options object before forwarding', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'from-global',
+          extra: 1
+        }),
+        getOptionValueSource: () => 'default'
+      };
+      capturedActions.import({
+        navy: 'subcommand-default'
+      }, fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.have.lengthOf(1);
+      (0, _chai.expect)(importSpy.firstCall.args[0]).to.eql({
+        navy: 'from-global',
+        extra: 1
+      });
+    });
+    it('should leave non-object trailing arguments untouched when stripping the command', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'global'
+        })
+      };
+      capturedActions.import(['web', 'api'], fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([['web', 'api']]);
+    });
+  });
   describe('basicCliWrapper action', function () {
     beforeEach(function () {
       loadModule();
@@ -349,6 +451,18 @@ describe('cli/program', function () {
       }, fakeCommand);
       (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('from-global');
     });
+    it('should fall back to maybeServices as opts when only an opts object and command are passed', async function () {
+      navyStub.getAvailableServiceNames = sandbox.stub().resolves([]);
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'from-global'
+        })
+      };
+      await actionsByCommand['available-services']({
+        navy: 'subcommand-default'
+      }, fakeCommand);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('from-global');
+    });
     it('should pass undefined when called with an empty service list', async function () {
       navyStub.start = sandbox.stub().resolves();
       await actionsByCommand.start([], {
@@ -454,6 +568,7 @@ describe('cli/program', function () {
     capturedActions = {};
     return {
       option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {

package/lib/cli/program.js

@@ -135,6 +135,11 @@ function lazyRequire(path) {
   };
 }
 const defaultNavy = process.env.NAVY_NAME || (0, _config.getConfig)().defaultNavy;
+
+// Strictly separate parent and subcommand options so an option that isn't
+// declared on a subcommand (e.g. `navy status -e foo`) is reported as
+// unknown rather than silently absorbed by the parent program.
+_commander.program.enablePositionalOptions();
 _commander.program.option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy);
 const importCommand = _commander.program.command('import').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Imports docker compose configuration from the current working directory and initialises a new navy').action(lazyRequire('./import'));
 (0, _configProvider.getImportCommandLineOptions)().forEach(opt => importCommand.option(...opt));

package/lib/cli/util/__tests__/merge-action-options.js

@@ -44,4 +44,28 @@ describe('cli/util/merge-action-options', function () {
     });
     (0, _chai.expect)(spy.calledOnce).to.equal(true);
   });
+  it('should let an explicit subcommand option beat the inherited parent default', function () {
+    const command = {
+      optsWithGlobals: () => ({
+        navy: 'parent-default'
+      }),
+      getOptionValueSource: key => key === 'navy' ? 'cli' : 'default'
+    };
+    const merged = (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'from-subcommand'
+    }, command);
+    (0, _chai.expect)(merged.navy).to.equal('from-subcommand');
+  });
+  it('should keep the parent value when the subcommand value came from its default', function () {
+    const command = {
+      optsWithGlobals: () => ({
+        navy: 'from-parent'
+      }),
+      getOptionValueSource: () => 'default'
+    };
+    const merged = (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'subcommand-default'
+    }, command);
+    (0, _chai.expect)(merged.navy).to.equal('from-parent');
+  });
 });

package/lib/cli/util/merge-action-options.js

@@ -6,15 +6,26 @@ Object.defineProperty(exports, "__esModule", {
 exports.mergeActionOptions = mergeActionOptions;
 /**
  * Merge Commander's per-command opts with inherited globals (e.g. `navy -e dev ps`).
- * `optsWithGlobals()` is the combined view; spread it after local opts so globals
- * override stale option defaults on the subcommand.
+ * `optsWithGlobals()` has "globals overwrite locals" semantics, which makes parent
+ * defaults win over child defaults. With positional options enabled, however, a
+ * value supplied after the subcommand name (e.g. `navy ps -e dev`) is parsed onto
+ * the subcommand, not the parent, so we re-apply any option whose source on the
+ * subcommand is non-default to keep the explicit value.
  */
 function mergeActionOptions(parsedOpts, command) {
   if (!command || typeof command.optsWithGlobals !== 'function') {
     return parsedOpts;
   }
-  return {
-    ...parsedOpts,
+  const merged = {
     ...command.optsWithGlobals()
   };
+  if (typeof command.getOptionValueSource === 'function') {
+    for (const key of Object.keys(parsedOpts)) {
+      const source = command.getOptionValueSource(key);
+      if (source && source !== 'default') {
+        merged[key] = parsedOpts[key];
+      }
+    }
+  }
+  return merged;
 }

package/lib/http-proxy.js

@@ -6,6 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.reconfigureHTTPProxy = reconfigureHTTPProxy;
 exports.resolveDockerSocketPath = resolveDockerSocketPath;
+exports.resolveProxyEnv = resolveProxyEnv;
+exports.resolveProxyEnvAllowlist = resolveProxyEnvAllowlist;
+exports.resolveProxyEnvFromNavyFile = resolveProxyEnvFromNavyFile;
 exports.resolveProxyImage = resolveProxyImage;
 var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
@@ -21,6 +24,43 @@ const DEFAULT_DOCKER_SOCKET = '/var/run/docker.sock';
 function resolveProxyImage(navyFile) {
   return process.env.NAVY_HTTP_PROXY_IMAGE || navyFile && navyFile.httpProxyImage || DEFAULT_PROXY_IMAGE;
 }
+function resolveProxyEnvFromNavyFile(navyFile) {
+  if (!navyFile) return {};
+  const raw = navyFile.httpProxyEnv;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const result = {};
+  for (const key of Object.keys(raw)) {
+    const value = raw[key];
+    if (value === null || value === undefined) continue;
+    const coerced = String(value);
+    if (coerced === '') continue;
+    result[key] = coerced;
+  }
+  return result;
+}
+function resolveProxyEnvAllowlist() {
+  const allowlist = process.env.NAVY_HTTP_PROXY_ENV;
+  if (!allowlist) return {};
+  const seen = new Set();
+  const result = {};
+  for (const rawName of allowlist.split(',')) {
+    const name = rawName.trim();
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const value = process.env[name];
+    if (typeof value !== 'string' || value === '') continue;
+    result[name] = value;
+  }
+  return result;
+}
+function resolveProxyEnv(navyFile) {
+  const merged = {
+    ...resolveProxyEnvFromNavyFile(navyFile),
+    ...resolveProxyEnvAllowlist()
+  };
+  if (Object.keys(merged).length === 0) return null;
+  return merged;
+}
 
 // Resolve the host path to the Docker socket. The proxy container needs to
 // read events from the same daemon as the rest of navy, so we honour
@@ -61,6 +101,7 @@ async function updateComposeConfig(navies, navyFile) {
     volumes.push(`${certsPath}:/etc/nginx/certs`);
     volumes.push(`${certsPath}:/etc/nginx/dhparam`); // to persist DH params
   }
+  const proxyEnv = resolveProxyEnv(navyFile);
   const config = {
     version: '2',
     services: {
@@ -69,6 +110,9 @@ async function updateComposeConfig(navies, navyFile) {
         ports,
         networks: networks.map(net => net.Name),
         volumes,
+        ...(proxyEnv ? {
+          environment: proxyEnv
+        } : {}),
         restart: 'always'
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navy",
-  "version": "7.0.0-alpha.2",
+  "version": "7.0.0-alpha.4",
   "description": "Quick and powerful development environments using Docker and Docker Compose",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",