navy 7.0.0-alpha.4 → 7.1.0

package/lib/cli/__tests__/https.js

@@ -18,6 +18,8 @@ describe('cli/https', function () {
   let createCertStub;
   let generateRootCaStub;
   let removeCertStub;
+  let issueLeafCertForUrlStub;
+  let installRootCaToTrustStoreStub;
   let fsStub;
   let consoleLogStub;
   let httpsCli;
@@ -40,6 +42,12 @@ describe('cli/https', function () {
     createCertStub = sandbox.stub().resolves();
     generateRootCaStub = sandbox.stub().resolves();
     removeCertStub = sandbox.stub().resolves();
+    issueLeafCertForUrlStub = sandbox.stub().resolves({
+      certPath: '/out/host.crt',
+      keyPath: '/out/host.key',
+      caCopyPath: '/out/navy-root-ca.crt'
+    });
+    installRootCaToTrustStoreStub = sandbox.stub();
     fsStub = {
       existsSync: sandbox.stub().returns(true),
       readdirSync: sandbox.stub().returns(['web.local.crt', 'api.local.crt', 'something.txt'])
@@ -63,7 +71,11 @@ describe('cli/https', function () {
       '../util/https': {
         createCert: createCertStub,
         generateRootCa: generateRootCaStub,
-        removeCert: removeCertStub
+        removeCert: removeCertStub,
+        issueLeafCertForUrl: issueLeafCertForUrlStub
+      },
+      '../util/install-root-ca': {
+        installRootCaToTrustStore: installRootCaToTrustStoreStub
       },
       fs: fsStub
     });
@@ -205,6 +217,186 @@ describe('cli/https', function () {
         const checkedPaths = fsStub.existsSync.getCalls().map(c => c.args[0]);
         (0, _chai.expect)(checkedPaths.some(p => p === '/custom-ca/ca.crt')).to.equal(true);
       });
+      it('should accept a single string service name', async function () {
+        await httpsCli('web', {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.callCount).to.equal(1);
+      });
+      it('should ignore non-string entries in a services array', async function () {
+        await httpsCli(['web', '', null, 42, 'api'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.callCount).to.equal(2);
+      });
+      it('should treat unsupported service arg types as an empty list', async function () {
+        fsStub.existsSync.returns(false);
+        await httpsCli(42, {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.called).to.equal(false);
+        (0, _chai.expect)(generateRootCaStub.called).to.equal(false);
+      });
+      it('should treat an empty string service arg as list mode', async function () {
+        fsStub.existsSync.returns(false);
+        await httpsCli('', {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.called).to.equal(false);
+      });
+    });
+    describe('validation', function () {
+      async function expectNavyError(promise, messagePattern) {
+        let caught;
+        try {
+          await promise;
+        } catch (err) {
+          caught = err;
+        }
+        (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+        (0, _chai.expect)(caught.message).to.match(messagePattern);
+      }
+      it('should reject combining disable with setup', async function () {
+        await expectNavyError(httpsCli([], {
+          disable: 'web',
+          setup: true
+        }), /cannot be combined/);
+      });
+      it('should reject combining disable with all', async function () {
+        await expectNavyError(httpsCli([], {
+          disable: 'web',
+          all: true
+        }), /cannot be combined/);
+      });
+      it('should reject combining disable with issue', async function () {
+        await expectNavyError(httpsCli([], {
+          disable: 'web',
+          issue: 'https://host'
+        }), /cannot be combined/);
+      });
+      it('should reject combining setup with all', async function () {
+        await expectNavyError(httpsCli([], {
+          setup: true,
+          all: true
+        }), /Use only one/);
+      });
+      it('should reject combining setup with issue', async function () {
+        await expectNavyError(httpsCli([], {
+          setup: true,
+          issue: 'https://host'
+        }), /Use only one/);
+      });
+      it('should reject combining all with issue', async function () {
+        await expectNavyError(httpsCli([], {
+          all: true,
+          issue: 'https://host'
+        }), /Use only one/);
+      });
+    });
+    describe('setup mode', function () {
+      it('should generate the root CA and install it in the trust store', async function () {
+        getConfigStub.returns({
+          tlsRootCaDir: '/custom-ca'
+        });
+        await httpsCli([], {
+          setup: true
+        });
+        (0, _chai.expect)(generateRootCaStub.calledOnce).to.equal(true);
+        (0, _chai.expect)(installRootCaToTrustStoreStub.calledOnce).to.equal(true);
+        (0, _chai.expect)(installRootCaToTrustStoreStub.firstCall.args[0]).to.equal('/custom-ca/ca.crt');
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('trust store');
+      });
+      it('should reject service names with setup', async function () {
+        let caught;
+        try {
+          await httpsCli(['web'], {
+            setup: true
+          });
+        } catch (err) {
+          caught = err;
+        }
+        (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+        (0, _chai.expect)(caught.message).to.contain('does not take service names');
+      });
+    });
+    describe('all mode', function () {
+      it('should enable HTTPS for every available service', async function () {
+        await httpsCli([], {
+          all: true,
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.callCount).to.equal(2);
+        (0, _chai.expect)(reconfigureHTTPProxyStub.calledOnce).to.equal(true);
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('web');
+        (0, _chai.expect)(printed).to.contain('api');
+      });
+      it('should generate the root CA when cert files are missing', async function () {
+        fsStub.existsSync.callsFake(p => !p.endsWith('ca.crt') && !p.endsWith('ca.key'));
+        await httpsCli([], {
+          all: true,
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(generateRootCaStub.calledOnce).to.equal(true);
+      });
+      it('should warn and return when no services are available', async function () {
+        navyStub.getAvailableServiceNames.resolves([]);
+        await httpsCli([], {
+          all: true,
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.called).to.equal(false);
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('No services found');
+      });
+      it('should reject service names with all', async function () {
+        let caught;
+        try {
+          await httpsCli(['web'], {
+            all: true
+          });
+        } catch (err) {
+          caught = err;
+        }
+        (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+        (0, _chai.expect)(caught.message).to.contain('does not take service names');
+      });
+    });
+    describe('issue mode', function () {
+      it('should issue a leaf cert for an external URL', async function () {
+        const cwdStub = sandbox.stub(process, 'cwd').returns('/current');
+        await httpsCli([], {
+          issue: 'https://external.local',
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(issueLeafCertForUrlStub.calledOnce).to.equal(true);
+        (0, _chai.expect)(issueLeafCertForUrlStub.firstCall.args).to.eql(['https://external.local', '/current']);
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('/out/host.crt');
+        (0, _chai.expect)(printed).to.contain('/out/host.key');
+        (0, _chai.expect)(printed).to.contain('/out/navy-root-ca.crt');
+        cwdStub.restore();
+      });
+      it('should honour issueOut when provided', async function () {
+        await httpsCli([], {
+          issue: 'https://external.local',
+          issueOut: '/custom/out'
+        });
+        (0, _chai.expect)(issueLeafCertForUrlStub.firstCall.args[1]).to.equal('/custom/out');
+      });
+      it('should reject service names with issue', async function () {
+        let caught;
+        try {
+          await httpsCli(['web'], {
+            issue: 'https://external.local'
+          });
+        } catch (err) {
+          caught = err;
+        }
+        (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+        (0, _chai.expect)(caught.message).to.contain('does not take service names');
+      });
     });
   });
 });

package/lib/cli/https.js

@@ -5,16 +5,64 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
+var _path = _interopRequireDefault(require("path"));
 var _chalk = _interopRequireDefault(require("chalk"));
 var _errors = require("../errors");
 var _navy = require("../navy");
 var _config = require("../config");
 var _httpProxy = require("../http-proxy");
 var _https = require("../util/https");
+var _installRootCa = require("../util/install-root-ca");
 var _fs = _interopRequireDefault(require("fs"));
+function normaliseServiceArgs(services) {
+  if (services == null) {
+    return [];
+  }
+  if (Array.isArray(services)) {
+    const result = [];
+    for (const s of services) {
+      if (typeof s === 'string' && s !== '') {
+        result.push(s);
+      }
+    }
+    return result;
+  }
+  if (typeof services === 'string') {
+    return services ? [services] : [];
+  }
+  return [];
+}
+async function issueHttpsForServices(navy, serviceNames, availableServices) {
+  const httpsReadyServices = [];
+  for (const service of serviceNames) {
+    if (!availableServices.includes(service)) {
+      console.log(`❌ ${service} not found, skipping`);
+      continue;
+    }
+    const serviceUrl = await navy.url(service);
+    try {
+      await (0, _https.createCert)({
+        serviceUrl
+      });
+      httpsReadyServices.push(service);
+    } catch (error) {
+      console.log(error);
+      throw new _errors.NavyError(`Could not generate TLS cert for ${service}`);
+    }
+  }
+  return httpsReadyServices;
+}
 async function _default(services, opts) {
   const tlsRootCaDir = (0, _config.getConfig)().tlsRootCaDir || _config.DEFAULT_TLS_ROOT_CA_DIR;
   const configDir = (0, _config.getConfigDir)();
+  const serviceList = normaliseServiceArgs(services);
+  const hasIssue = Boolean(opts.issue);
+  if (opts.disable && (opts.setup || opts.all || hasIssue)) {
+    throw new _errors.NavyError('`--disable` cannot be combined with `--setup`, `--all`, or `--issue`.');
+  }
+  if ([opts.setup, opts.all, hasIssue].filter(Boolean).length > 1) {
+    throw new _errors.NavyError('Use only one of `--setup`, `--all`, or `--issue`.');
+  }
   if (opts.disable) {
     await (0, _https.removeCert)(opts);
 
@@ -31,7 +79,60 @@ async function _default(services, opts) {
     console.log();
     return;
   }
-  if (!services || services.length === 0) {
+  if (opts.setup) {
+    if (serviceList.length > 0) {
+      throw new _errors.NavyError('`navy https --setup` does not take service names. Run `navy https <service>…` separately to issue service certificates.');
+    }
+    await (0, _https.generateRootCa)();
+    const caCrt = _path.default.join(tlsRootCaDir, 'ca.crt');
+    (0, _installRootCa.installRootCaToTrustStore)(caCrt);
+    console.log();
+    console.log(_chalk.default.green('✅ Navy root CA is installed in your trust store (where supported).'));
+    console.log(_chalk.default.dim('Browsers that use their own NSS store (e.g. Firefox) may still need the CA imported there.'));
+    console.log();
+    return;
+  }
+  if (opts.all) {
+    if (serviceList.length > 0) {
+      throw new _errors.NavyError('`navy https --all` does not take service names. Omit them, or name services without `--all`.');
+    }
+    if (!_fs.default.existsSync(`${tlsRootCaDir}/ca.crt`) || !_fs.default.existsSync(`${tlsRootCaDir}/ca.key`)) {
+      await (0, _https.generateRootCa)();
+    }
+    const navy = await (0, _navy.getNavy)(opts.navy);
+    await navy.ensurePluginsLoaded();
+    const availableServices = await navy.getAvailableServiceNames();
+    if (availableServices.length === 0) {
+      console.log();
+      console.log(_chalk.default.yellow('No services found in this navy; nothing to enable HTTPS for.'));
+      console.log();
+      return;
+    }
+    const httpsReadyServices = await issueHttpsForServices(navy, availableServices, availableServices);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      restart: true,
+      navyFile: await navy.getNavyFile()
+    });
+    console.log();
+    console.log(_chalk.default.green(`✅ Service(s) ${httpsReadyServices.join(', ')} now accessible via HTTPS🔒`));
+    console.log();
+    return;
+  }
+  if (hasIssue) {
+    if (serviceList.length > 0) {
+      throw new _errors.NavyError('`navy https --issue` does not take service names.');
+    }
+    const outDir = opts.issueOut ? _path.default.resolve(opts.issueOut) : process.cwd();
+    const paths = await (0, _https.issueLeafCertForUrl)(String(opts.issue), outDir);
+    console.log();
+    console.log(_chalk.default.green('✅ TLS certificate issued for use outside Navy:'));
+    console.log(`   ${paths.certPath}`);
+    console.log(`   ${paths.keyPath}`);
+    console.log(`   ${paths.caCopyPath} (root CA; configure clients to trust this or append as a chain file)`);
+    console.log();
+    return;
+  }
+  if (serviceList.length === 0) {
     if (!_fs.default.existsSync(`${configDir}/tls-certs`)) return;
     const files = _fs.default.readdirSync(`${configDir}/tls-certs`);
     const urls = files.filter(file => file.endsWith('.crt')).map(crt => {
@@ -48,23 +149,7 @@ async function _default(services, opts) {
   const navy = await (0, _navy.getNavy)(opts.navy);
   await navy.ensurePluginsLoaded();
   const availableServices = await navy.getAvailableServiceNames();
-  const httpsReadyServices = [];
-  for (const service of services) {
-    if (!availableServices.includes(service)) {
-      console.log(`❌ ${service} not found, skipping`);
-      continue;
-    }
-    const serviceUrl = await navy.url(service);
-    try {
-      await (0, _https.createCert)({
-        serviceUrl
-      });
-      httpsReadyServices.push(service);
-    } catch (error) {
-      console.log(error);
-      throw new _errors.NavyError(`Could not generate TLS cert for ${service}`);
-    }
-  }
+  const httpsReadyServices = await issueHttpsForServices(navy, serviceList, availableServices);
   await (0, _httpProxy.reconfigureHTTPProxy)({
     restart: true,
     navyFile: await navy.getNavyFile()

package/lib/cli/program.js

@@ -171,7 +171,7 @@ _commander.program.command('health').option('-e, --navy [env]', `set the navy na
 _commander.program.command('wait-for-healthy [services...]').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Waits for the given services to be healthy').action(lazyRequire('./wait-for-healthy'));
 _commander.program.command('use-tag <service> <tag>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Uses a specific tag for the given service').action(basicCliWrapper('useTag'));
 _commander.program.command('reset-tag <service>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Resets any tag override on the given service').action(basicCliWrapper('resetTag'));
-_commander.program.command('https [services...]').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).option('-d, --disable <service>', 'disable https (deletes cert) for a given service', null).description('Prints or enables HTTPS services').action(lazyRequire('./https')).on('--help', () => console.log(`
+_commander.program.command('https [services...]').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).option('-d, --disable <service>', 'disable https (deletes cert) for a given service', null).option('-s, --setup', 'generate the Navy root CA (if needed) and install it in the system trust store').option('-a, --all', 'enable HTTPS for every service in this navy').option('-i, --issue <url>', 'issue a TLS certificate and key for a URL (non-Navy service), signed with the Navy root CA').option('-o, --issue-out <dir>', 'output directory for --issue (default: current working directory)').description('Prints or enables HTTPS services').action(lazyRequire('./https')).on('--help', () => console.log(`
   Examples:
     List urls of services that listen on https:
     $ navy https
@@ -179,8 +179,18 @@ _commander.program.command('https [services...]').option('-e, --navy [env]', `se
     Enable https for mywebservice and anotherwebservice services
     $ navy https mywebservice anotherwebservice
 
+    Enable https for all services
+    $ navy https --all
+
     Disable https for mywebservice
     $ navy https -d mywebservice
+
+    Generate the Navy root CA and install it for this user (no service names)
+    $ navy https --setup
+
+    Issue a cert for an external host (writes leaf key/cert + navy-root-ca.crt)
+    $ navy https --issue https://api.example.test
+    $ navy https --issue https://api.example.test -o ./tls
   `));
 _commander.program.command('use-port <service> <internal> <external>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Uses a specific external port for the given service and internal port').action(basicCliWrapper('usePort'));
 _commander.program.command('reset-port <service> <internal>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Resets a specific external port mapping set by use-port').action(basicCliWrapper('resetPort'));

package/lib/navy/__tests__/index.js

@@ -776,6 +776,148 @@ describe('navy/index', function () {
       (0, _chai.expect)(driver.destroy.calledOnce).to.equal(true);
       (0, _chai.expect)(deleteState.calledOnce).to.equal(true);
     });
+    it('should pass navyFile from a remaining navy when reconfiguring the proxy', async function () {
+      const driver = makeDriver();
+      const envPath = '/abs/env/Navyfile.js';
+      const otherPath = '/abs/other/Navyfile.js';
+      const destroyedNavyFile = {
+        httpProxyImage: 'destroyed/proxy:1'
+      };
+      const remainingNavyFile = {
+        httpProxyImage: 'remaining/proxy:1',
+        httpProxyEnv: {
+          FOO: 'bar'
+        }
+      };
+      const createProvider = path => ({
+        getNavyFilePath: async () => path
+      });
+      const resolveConfigProvider = _sinon.default.stub().callsFake(() => navy => createProvider(navy.normalisedName === 'other' ? otherPath : envPath));
+      const reconfigureHTTPProxy = _sinon.default.stub().resolves();
+      const deleteState = _sinon.default.stub().resolves();
+      const {
+        Navy
+      } = _proxyquire.default.noCallThru()('../', {
+        '../util/fs': {
+          readdirAsync: _sinon.default.stub().resolves(['env', 'other']),
+          lstatSync: _sinon.default.stub().returns({
+            isDirectory: () => true
+          })
+        },
+        './state': {
+          getState: _sinon.default.stub().resolves({
+            driver: 'docker-compose',
+            configProvider: 'filesystem'
+          }),
+          saveState: _sinon.default.stub().resolves(),
+          deleteState,
+          pathToNavys: _sinon.default.stub().returns('/home/test/.navy/navies'),
+          pathToNavy: _sinon.default.stub().callsFake(n => `/home/test/.navy/navies/${n}`)
+        },
+        '../driver': {
+          resolveDriverFromName: _sinon.default.stub().returns(() => driver)
+        },
+        '../config-provider': {
+          resolveConfigProviderFromName: resolveConfigProvider
+        },
+        '../config': {
+          getConfig: _sinon.default.stub().returns({
+            externalIP: null
+          })
+        },
+        './plugin-interface': {
+          loadPlugins: _sinon.default.stub().resolves([])
+        },
+        './middleware': {
+          middlewareRunner: _sinon.default.stub().resolves()
+        },
+        '../http-proxy': {
+          reconfigureHTTPProxy
+        },
+        '../util/external-ip': {
+          getExternalIP: _sinon.default.stub().resolves('127.0.0.1')
+        },
+        '../util/service-host': {
+          createUrlForService: _sinon.default.stub().resolves('http://svc.local'),
+          getUrlFromService: _sinon.default.stub().returns(null)
+        },
+        [envPath]: destroyedNavyFile,
+        [otherPath]: remainingNavyFile
+      });
+      await new Navy('env').destroy();
+      (0, _chai.expect)(reconfigureHTTPProxy.calledOnce).to.equal(true);
+      (0, _chai.expect)(reconfigureHTTPProxy.firstCall.args[0].navies).to.eql(['other']);
+      (0, _chai.expect)(reconfigureHTTPProxy.firstCall.args[0].navyFile).to.eql(remainingNavyFile);
+    });
+    it('should skip uninitialised remaining navies when resolving navyFile for the proxy', async function () {
+      const driver = makeDriver();
+      const otherPath = '/abs/other/Navyfile.js';
+      const remainingNavyFile = {
+        httpProxyImage: 'remaining/proxy:1'
+      };
+      const createProvider = path => ({
+        getNavyFilePath: async () => path
+      });
+      const resolveConfigProvider = _sinon.default.stub().callsFake(() => navy => createProvider(navy.normalisedName === 'other' ? otherPath : '/abs/env/Navyfile.js'));
+      const reconfigureHTTPProxy = _sinon.default.stub().resolves();
+      const deleteState = _sinon.default.stub().resolves();
+      const getState = _sinon.default.stub().callsFake(name => {
+        if (name === 'uninit') return Promise.resolve(null);
+        return Promise.resolve({
+          driver: 'docker-compose',
+          configProvider: 'filesystem'
+        });
+      });
+      const {
+        Navy
+      } = _proxyquire.default.noCallThru()('../', {
+        '../util/fs': {
+          readdirAsync: _sinon.default.stub().resolves(['env', 'uninit', 'other']),
+          lstatSync: _sinon.default.stub().returns({
+            isDirectory: () => true
+          })
+        },
+        './state': {
+          getState,
+          saveState: _sinon.default.stub().resolves(),
+          deleteState,
+          pathToNavys: _sinon.default.stub().returns('/home/test/.navy/navies'),
+          pathToNavy: _sinon.default.stub().callsFake(n => `/home/test/.navy/navies/${n}`)
+        },
+        '../driver': {
+          resolveDriverFromName: _sinon.default.stub().returns(() => driver)
+        },
+        '../config-provider': {
+          resolveConfigProviderFromName: resolveConfigProvider
+        },
+        '../config': {
+          getConfig: _sinon.default.stub().returns({
+            externalIP: null
+          })
+        },
+        './plugin-interface': {
+          loadPlugins: _sinon.default.stub().resolves([])
+        },
+        './middleware': {
+          middlewareRunner: _sinon.default.stub().resolves()
+        },
+        '../http-proxy': {
+          reconfigureHTTPProxy
+        },
+        '../util/external-ip': {
+          getExternalIP: _sinon.default.stub().resolves('127.0.0.1')
+        },
+        '../util/service-host': {
+          createUrlForService: _sinon.default.stub().resolves('http://svc.local'),
+          getUrlFromService: _sinon.default.stub().returns(null)
+        },
+        [otherPath]: remainingNavyFile
+      });
+      await new Navy('env').destroy();
+      (0, _chai.expect)(reconfigureHTTPProxy.calledOnce).to.equal(true);
+      (0, _chai.expect)(reconfigureHTTPProxy.firstCall.args[0].navies).to.eql(['uninit', 'other']);
+      (0, _chai.expect)(reconfigureHTTPProxy.firstCall.args[0].navyFile).to.eql(remainingNavyFile);
+    });
     it('should still delete state even when driver.destroy throws', async function () {
       const driver = makeDriver({
         destroy: _sinon.default.stub().rejects(new Error('boom'))

package/lib/navy/index.js

@@ -237,9 +237,10 @@ class Navy extends _eventemitter.EventEmitter2 {
     if (!(await this.isInitialised())) {
       throw new _errors.NavyNotInitialisedError(this.name);
     }
+    const remainingNavyNames = (await getLaunchedNavyNames()).filter(navy => navy !== this.normalisedName);
     await (0, _httpProxy.reconfigureHTTPProxy)({
-      navies: (await getLaunchedNavyNames()).filter(navy => navy !== this.normalisedName),
-      navyFile: await this.getNavyFile()
+      navies: remainingNavyNames,
+      navyFile: await getNavyFileFromNavies(remainingNavyNames)
     });
     try {
       await (await this.safeGetDriver()).destroy();
@@ -499,6 +500,15 @@ function getNavy(navyName) {
   (0, _invariant.default)(navyName, "NO_NAVY_PROVIDED: No Navy provided");
   return new Navy(navyName);
 }
+async function getNavyFileFromNavies(navyNames) {
+  for (const navyName of navyNames) {
+    const navy = getNavy(navyName);
+    if (!(await navy.isInitialised())) continue;
+    const navyFile = await navy.getNavyFile();
+    if (navyFile) return navyFile;
+  }
+  return null;
+}
 
 /**
  * Returns an array of `Navy` instances which are currently imported and launched.