feat: You can now use web-ext programatically, e.g. webExt.cmd.run()

bin/web-ext

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+var webExt = require('../dist/web-ext').default;
 var path = require('path');
 var absolutePackageDir = path.join(path.resolve(__dirname), '..');
-require('../dist/web-ext').main(absolutePackageDir);
+
+webExt.main(absolutePackageDir);

src/cmd/build.js

@@ -175,6 +175,7 @@ export type BuildCmdParams = {|
   sourceDir: string,
   artifactsDir: string,
   asNeeded?: boolean,
+  noInput?: boolean,
   overwriteDest?: boolean,
   ignoreFiles?: Array<string>,
 |};
@@ -196,6 +197,7 @@ export default async function build(
     asNeeded = false,
     overwriteDest = false,
     ignoreFiles = [],
+    noInput = false,
   }: BuildCmdParams,
   {
     manifestData,

src/cmd/docs.js

@@ -5,16 +5,20 @@ import {createLogger} from '../util/logger';
 
 const log = createLogger(__filename);
 
+type DocsParams = {
+  noInput?: boolean,
+  shouldExitProgram?: boolean,
+}
+
 type DocsOptions = {
   openUrl?: typeof defaultUrlOpener,
-  shouldExitProgram?: boolean,
 }
 
 export const url = 'https://developer.mozilla.org/en-US/Add-ons' +
   '/WebExtensions/Getting_started_with_web-ext';
 
 export default function docs(
-  params: Object, {openUrl = defaultUrlOpener}: DocsOptions = {}
+  params: DocsParams, {openUrl = defaultUrlOpener}: DocsOptions = {}
 ) {
   return new Promise((resolve, reject) => {
     openUrl(url, (error) => {

src/cmd/index.js

@@ -6,4 +6,3 @@ import sign from './sign';
 import docs from './docs';
 
 export default {build, lint, run, sign, docs};
-

src/cmd/lint.js

@@ -41,16 +41,17 @@ export type LinterCreatorFn = (params: LinterCreatorParams) => Linter;
 // Lint command types and implementation.
 
 export type LintCmdParams = {|
-  sourceDir: string,
-  verbose?: boolean,
-  selfHosted?: boolean,
+  artifactsDir?: string,
   boring?: boolean,
-  output?: LinterOutputType,
+  ignoreFiles?: Array<string>,
   metadata?: boolean,
+  noInput?: boolean,
+  output?: LinterOutputType,
   pretty?: boolean,
+  selfHosted?: boolean,
+  sourceDir: string,
+  verbose?: boolean,
   warningsAsErrors?: boolean,
-  ignoreFiles?: Array<string>,
-  artifactsDir?: string,
 |};
 
 export type LintCmdOptions = {|
@@ -61,8 +62,17 @@ export type LintCmdOptions = {|
 
 export default function lint(
   {
-    verbose, sourceDir, selfHosted, boring, output,
-    metadata, pretty, warningsAsErrors, ignoreFiles, artifactsDir,
+    artifactsDir,
+    boring,
+    ignoreFiles,
+    metadata,
+    noInput = false,
+    output,
+    pretty,
+    sourceDir,
+    selfHosted,
+    verbose,
+    warningsAsErrors,
   }: LintCmdParams,
   {
     createLinter = defaultLinterCreator,

src/cmd/run.js

@@ -22,17 +22,18 @@ const log = createLogger(__filename);
 // Run command types and implementation.
 
 export type CmdRunParams = {|
-  sourceDir: string,
   artifactsDir: string,
+  browserConsole: boolean,
+  customPrefs?: FirefoxPreferences,
   firefox: string,
   firefoxProfile?: string,
+  ignoreFiles?: Array<string>,
   keepProfileChanges: boolean,
-  preInstall: boolean,
+  noInput?: boolean,
   noReload: boolean,
-  browserConsole: boolean,
-  customPrefs?: FirefoxPreferences,
+  preInstall: boolean,
+  sourceDir: string,
   startUrl?: string | Array<string>,
-  ignoreFiles?: Array<string>,
 |};
 
 export type CmdRunOptions = {|
@@ -48,9 +49,18 @@ export type CmdRunOptions = {|
 
 export default async function run(
   {
-    sourceDir, artifactsDir, firefox, firefoxProfile,
-    keepProfileChanges = false, preInstall = false, noReload = false,
-    browserConsole = false, customPrefs, startUrl, ignoreFiles,
+    artifactsDir,
+    browserConsole = false,
+    customPrefs,
+    firefox,
+    firefoxProfile,
+    keepProfileChanges = false,
+    ignoreFiles,
+    noInput = false,
+    noReload = false,
+    preInstall = false,
+    sourceDir,
+    startUrl,
   }: CmdRunParams,
   {
     desktopNotifications = defaultDesktopNotifications,
@@ -111,6 +121,7 @@ export default async function run(
       sourceDir,
       artifactsDir,
       ignoreFiles,
+      noInput,
     });
   }
 

src/cmd/sign.js

@@ -20,16 +20,17 @@ export const extensionIdFile = '.web-extension-id';
 // Sign command types and implementation.
 
 export type SignParams = {|
-  id?: string,
-  verbose?: boolean,
-  sourceDir: string,
-  artifactsDir: string,
-  ignoreFiles?: Array<string>,
   apiKey: string,
+  apiProxy: string,
   apiSecret: string,
   apiUrlPrefix: string,
-  apiProxy: string,
+  artifactsDir: string,
+  id?: string,
+  ignoreFiles?: Array<string>,
+  noInput?: boolean,
+  sourceDir: string,
   timeout: number,
+  verbose?: boolean,
 |};
 
 export type SignOptions = {
@@ -47,12 +48,22 @@ export type SignResult = {|
 
 export default function sign(
   {
-    verbose, sourceDir, artifactsDir, ignoreFiles = [],
-    apiKey, apiSecret, apiUrlPrefix, apiProxy, id, timeout,
+    apiKey,
+    apiProxy,
+    apiSecret,
+    apiUrlPrefix,
+    artifactsDir,
+    id,
+    ignoreFiles = [],
+    noInput = false,
+    sourceDir,
+    timeout,
+    verbose,
   }: SignParams,
   {
-    build = defaultBuilder, signAddon = defaultAddonSigner,
+    build = defaultBuilder,
     preValidatedManifest,
+    signAddon = defaultAddonSigner,
   }: SignOptions = {}
 ): Promise<SignResult> {
   return withTempDir(

src/extension-runners/index.js

@@ -236,6 +236,7 @@ export type ReloadStrategyParams = {|
   sourceDir: string,
   artifactsDir: string,
   ignoreFiles?: Array<string>,
+  noInput?: boolean,
 |};
 
 export type ReloadStrategyOptions = {|
@@ -246,15 +247,23 @@ export type ReloadStrategyOptions = {|
 
 export function defaultReloadStrategy(
   {
+    artifactsDir,
     extensionRunner,
-    sourceDir, artifactsDir, ignoreFiles,
+    ignoreFiles,
+    noInput = false,
+    sourceDir,
   }: ReloadStrategyParams,
   {
     createWatcher = defaultWatcherCreator,
     stdin = process.stdin,
     kill = process.kill,
   }: ReloadStrategyOptions = {}
 ): void {
+  const allowInput = !noInput;
+  if (!allowInput) {
+    log.debug('Input has been disabled because of noInput==true');
+  }
+
   const watcher: Watchpack = createWatcher({
     reloadExtension: (watchedSourceDir) => {
       extensionRunner.reloadExtensionBySourceDir(watchedSourceDir);
@@ -266,10 +275,12 @@ export function defaultReloadStrategy(
 
   extensionRunner.registerCleanup(() => {
     watcher.close();
-    stdin.pause();
+    if (allowInput) {
+      stdin.pause();
+    }
   });
 
-  if (stdin.isTTY && stdin instanceof tty.ReadStream) {
+  if (allowInput && stdin.isTTY && stdin instanceof tty.ReadStream) {
     readline.emitKeypressEvents(stdin);
     stdin.setRawMode(true);
 

src/main.js

@@ -1,4 +1,10 @@
 /* @flow */
 import {main} from './program';
+import cmd from './cmd';
+import * as logger from './util/logger';
 
-export {main};
+// This only exposes util/logger so far.
+// Do we need anything else?
+const util = {logger};
+
+export default {main, cmd, util};

tests/unit/test-cmd/test.run.js

@@ -136,6 +136,14 @@ describe('run', () => {
     assert.equal(args.artifactsDir, artifactsDir);
   });
 
+  it('can disable input in the reload strategy', async () => {
+    const cmd = prepareRun();
+    const {reloadStrategy} = cmd.options;
+
+    await cmd.run({noInput: true, noReload: false});
+    sinon.assert.calledWithMatch(reloadStrategy, {noInput: true});
+  });
+
   it('will not reload when using --pre-install', async () => {
     const cmd = prepareRun();
     const {reloadStrategy} = cmd.options;

tests/unit/test-extension-runners/test.extension-runners.js

@@ -500,6 +500,27 @@ describe('util/extension-runners', () => {
       }
     });
 
+    it('allows you to disable input', async () => {
+      const {extensionRunner, reloadStrategy} = prepare();
+      sinon.spy(extensionRunner, 'registerCleanup');
+
+      const fakeStdin = new tty.ReadStream();
+      sinon.spy(fakeStdin, 'pause');
+      sinon.spy(fakeStdin, 'setRawMode');
+
+      try {
+        await reloadStrategy({noInput: true}, {stdin: fakeStdin});
+        // This is meant to test that all input is ignored.
+        sinon.assert.notCalled(fakeStdin.setRawMode);
+      } finally {
+        exitKeypressLoop(fakeStdin);
+      }
+
+      const cleanupCb = extensionRunner.registerCleanup.firstCall.args[0];
+      cleanupCb();
+      sinon.assert.notCalled(fakeStdin.pause);
+    });
+
     it('can still reload when user presses R after a reload error',
       async () => {
         const {extensionRunner, reloadStrategy} = prepare({

tests/unit/test.web-ext.js

@@ -0,0 +1,26 @@
+/* @flow */
+import {describe, it} from 'mocha';
+import {assert} from 'chai';
+
+import webExt from '../../src/main';
+import build from '../../src/cmd/build';
+import run from '../../src/cmd/run';
+import {main} from '../../src/program';
+import {consoleStream} from '../../src/util/logger';
+
+
+describe('webExt', () => {
+  it('exposes main', () => {
+    assert.equal(webExt.main, main);
+  });
+
+  it('exposes commands', () => {
+    // This just checks a sample of commands.
+    assert.equal(webExt.cmd.run, run);
+    assert.equal(webExt.cmd.build, build);
+  });
+
+  it('gives you access to the log stream', () => {
+    assert.equal(webExt.util.logger.consoleStream, consoleStream);
+  });
+});