function protractor(callback, args, testId: string) {
  const buildConfig = require('../../build/config');
  const app = connect().use(serveStatic(PROJECT_ROOT));
  const protractorHttpServer = createServer(app).listen(buildConfig.protractorPort);

  console.log(`Serving ${process.cwd()} on http://localhost:${buildConfig.protractorPort}`);

  const child = spawn('protractor', args, {
    stdio: [process.stdin, process.stdout, 'pipe']
  });

  let errored = false;
  let callbackCalled = false;

  child.stderr.on('data', function(data) {
    protractorHttpServer.close();
    console.error(data.toString());
    if (!errored) {
      errored = true;
      if (!callbackCalled) {
        callback('Protractor tests failed.');
        callbackCalled = true;
      }
    }
  });

  child.on('exit', function() {
    protractorHttpServer.close();
    if (!callbackCalled) {
      console.log(`[snapshot] TestId: ${testId}`);
      callback();
      callbackCalled = true;
    }
  });
}

export async function devCommand(config: Config, args) {
  const port = args["x"] || args["port"] || 8000;
  const path = args["p"] || args["path"] || process.cwd();
  const workingDir = await searchForProjectDir(path);
  const servePath = join(workingDir, config.caches.DEPLOY_DIR);
  const lede = loadLede(workingDir, config.logger);
  const logger = config.logger;

  // Dependency instantiation
  const deployer = new lede.deployers.FileSystemDeployer({workingDir: servePath, logger});
  const htmlCompiler = new lede.compilers.NunjucksCompiler(Object.assign({}, config.htmlCompilerArgs, {logger}));
  const styleCompiler = new lede.compilers.SassCompiler(Object.assign({}, config.styleCompilerArgs, { cacheDir: config.caches.COMPILER_CACHE, logger }));
  const scriptCompiler = new lede.compilers.Es6Compiler(Object.assign({}, config.scriptCompilerArgs, { cacheDir: config.caches.COMPILER_CACHE, logger }));
  const projectDirector = new lede.ProjectDirector({ workingDir, depCacheDir: config.caches.DEP_CACHE, deployer, logger, htmlCompiler, scriptCompiler, styleCompiler, debug: true });
  const fileServer = connect();
  const lrServer = livereload.createServer();

  await projectDirector.compile();

  await initializeWatchers({ workingDir, depCacheDir: config.caches.DEP_CACHE, projectDirector});
  fileServer.use(serveStatic(servePath));
  fileServer.listen(port);
  const pageModels = await Promise.all(
    projectDirector.model.pages.map(p => projectDirector.model.getPageTree({name: p.name, debug: true}))
  );
  const livereloadPaths = pageModels.map(p => join(servePath, p.context.$PROJECT.$name, p.context.$PAGE.$name));
  lrServer.watch(livereloadPaths);
  logger.info(`Project ${projectDirector.model.project.name} has finished compiling and is being watched for changes.`);
  for (let page of pageModels) {
    logger.info(`Serving ${page.context.$PAGE.$name} at http://localhost:${port}/${page.context.$PROJECT.$name}/${page.context.$PAGE.$name}`);
  }
  return new Promise((resolve, reject) => {

  });
}

function createConnectApp(options: CreateAppOptions = {}) {
  const app = connect();

  options.apolloOptions = options.apolloOptions || { schema: Schema };
  if (!options.excludeParser) {
    app.use('/graphql', bodyParser.json());
  }
  if (options.graphiqlOptions ) {
    app.use('/graphiql', graphiqlConnect( options.graphiqlOptions ));
  }
  app.use('/graphql', apolloConnect( options.apolloOptions ));
  return app;
}

    constructor(config: Config) {
        super();
        // var middleware = this.intercept.bind(this);
        this.config = config;
        const { port, protocol, target, targetPort, path } = config;
        const url = `${protocol}://${target}:${targetPort || "80"}${path || ""}`;

        this.app = connect();
        // PROXY SET
        config.target = url;
        this.proxy = httpProxy.createProxyServer(config);
        this.proxy.on('error', (err)=> {
            return console.log(err);
        });
    }

function createConnectApp(options: CreateAppOptions = {}) {
  const app = connect();
  // We do require users of ApolloServer with connect to use a query middleware
  // first. The alternative is to add a 'isConnect' bool to ServerRegistration
  // and make qs-middleware be a dependency of this package. However, we don't
  // think many folks use connect outside of Meteor anyway, and anyone using
  // connect is probably already using connect-query or qs-middleware.
  app.use(query());
  const server = new ApolloServer(
    (options.graphqlOptions as Config) || { schema: Schema },
  );
  // See comment on ServerRegistration.app for its typing.
  server.applyMiddleware({ app: app as any });
  return app;
}

export async function devCommand({workingDir, args, logger}) {
  let name = args['n'] || args['name'];
  let port = args['x'] || args['port'] || 8000;
  let {servePath, buildPath} = await getPaths(workingDir, name, logger);
  let compilerPath = args['c'] || args['compilers'] || resolve(workingDir, "compilers", "compilerConfig.js");
  let compilers = await getCompilers(compilerPath, logger);
  let lede = new Lede(buildPath, compilers,
    {dev: new FileSystemDeployer(servePath)}, logger);
  let fileServer = connect();
  let lrServer: any = livereload.createServer();

  fileServer.use(serveStatic(servePath));
  let projectReport = await lede.deploy("dev", true);
  createWatcher({lede, projectReport, logger});
  logger.info(`Serving at ${chalk.green(`localhost:${port}/`)}`);
  lrServer.watch(servePath);
  fileServer.listen(port);
}

	constructor(host, port) {
		Util.statusMsg('Setting up web server.');

		let protocol = (port === 443) ? 'https' : 'http';
		this.protocol = protocol;
		this.host = host;
		this.port = port;
		this.url = protocol + '://' + host + (protocol === 'http' && port !== 80 ? ':' + port : '') + '/';

		this.index = path.resolve(__dirname, './public');
		this.site = connect();
		this.site.use(serveStatic(this.index));
		this._server = null;

		this.isRestarting = false;
		this.restartPending = false;

		Util.statusMsg('Web server started successfully.');
	}

export function launchEchoServer(echoServerPort: number) {

    const echoServer = connect();
    echoServer.use(checkForKillCommand);
    echoServer.use(function(req: IncomingMessage, res: ServerResponse) {
        let urlParts = req.url.split("?");

        let returnResponse = () => {
            res.setHeader('Content-Type', 'text/plain');
            res.writeHead(200);
            req.pipe(res);
        };

        if (urlParts.length > 1) {
            const parameters = querystring.parse(urlParts[1]);

            if (parameters.d) {
                res.setHeader('d', parameters.d);
            }
        
            if (parameters.t) {
                res.setHeader('t', parameters.t);
                setTimeout(returnResponse, parameters.t)
            }
            else {
                returnResponse();
            }
            return;
        }

        returnResponse();

    });

    http.createServer(echoServer).listen(echoServerPort);
    console.log("Echo server listening on " + echoServerPort);
};

    constructor(option: Option) {
      this.option = option;
      this.app = connect();

    }

export function createWebpackDevServer(callback: CreateDevServerCallback, optionsJson: string) {
    const options: CreateDevServerOptions = JSON.parse(optionsJson);
    const webpackConfig: webpack.Configuration = requireNewCopy(options.webpackConfigPath);
    const publicPath = (webpackConfig.output.publicPath || '').trim();
    if (!publicPath) {
        callback('To use the Webpack dev server, you must specify a value for \'publicPath\' on the \'output\' section of your webpack.config.', null);
        return;
    }

    const enableHotModuleReplacement = options.suppliedOptions.HotModuleReplacement;
    const enableReactHotModuleReplacement = options.suppliedOptions.ReactHotModuleReplacement;
    if (enableReactHotModuleReplacement && !enableHotModuleReplacement) {
        callback('To use ReactHotModuleReplacement, you must also enable the HotModuleReplacement option.', null);
        return;
    }

    const app = connect();
    const defaultPort = 0; // 0 means 'choose randomly'. Could allow an explicit value to be supplied instead.
    const listener = app.listen(defaultPort, () => {
        // Build the final Webpack config based on supplied options
        if (enableHotModuleReplacement) {
            // TODO: Stop assuming there's an entry point called 'main'
            if (typeof webpackConfig.entry['main'] === 'string') {
              webpackConfig.entry['main'] = ['webpack-hot-middleware/client', webpackConfig.entry['main']];
            } else {
              webpackConfig.entry['main'].unshift('webpack-hot-middleware/client');
            }
            webpackConfig.plugins.push(
                new webpack.HotModuleReplacementPlugin()
            );

            // Set up React HMR support if requested. This requires the 'aspnet-webpack-react' package.
            if (enableReactHotModuleReplacement) {
                let aspNetWebpackReactModule: any;
                try {
                    aspNetWebpackReactModule = require('aspnet-webpack-react');
                } catch(ex) {
                    callback('To use ReactHotModuleReplacement, you must install the NPM package \'aspnet-webpack-react\'.', null);
                    return;
                }

                aspNetWebpackReactModule.addReactHotModuleReplacementBabelTransform(webpackConfig);
            }
        }

        // Attach Webpack dev middleware and optional 'hot' middleware
        const compiler = webpack(webpackConfig);
        app.use(require('webpack-dev-middleware')(compiler, {
            noInfo: true,
            publicPath: publicPath
        }));

        if (enableHotModuleReplacement) {
            let webpackHotMiddlewareModule;
            try {
                webpackHotMiddlewareModule = require('webpack-hot-middleware');
            } catch (ex) {
                callback('To use HotModuleReplacement, you must install the NPM package \'webpack-hot-middleware\'.', null);
                return;
            }
            app.use(webpackHotMiddlewareModule(compiler));
        }

        // Tell the ASP.NET app what addresses we're listening on, so that it can proxy requests here
        callback(null, {
            Port: listener.address().port,
            PublicPath: removeTrailingSlash(publicPath)
        });
    });
}