async readPem(p: string): Promise<string> {
   try {
     return await readFile(p, { encoding: 'utf8' });
   } catch (e) {
     process.stderr.write(String(e.stack ? e.stack : e) + '\n');
     throw new Error(`Error encountered with ${p}`);
   }
 }

 it('should stringify with config4 file', async () => {
   const config4 = await readFile(path.resolve(__dirname, 'fixtures/ssh-config/config4'), { encoding: 'utf8' });
   const conf = SSHConfig.parse(config4);
   ensureHostAndKeyPath(conf, { host: 'bar' }, '/id_rsa');
   const s = config4.split('\n');
   s[s.length - 2] = '    IdentityFile /id_rsa';
   expect(SSHConfig.stringify(conf)).toEqual(s.join('\n'));
 });

      it('should inject script into app template', async () => {
        // TODO: this test is fragile and gross
        const apphtml = await readFile(path.resolve(__dirname, 'fixtures/dev-server/app.html'), { encoding: 'utf8' });
        const code = `
    <script src="script.js"></script>
`;

        const result = injectScript(apphtml, code);
        const lines = apphtml.split('\n');
        lines.splice(-3);
        expect(result).toEqual(lines.join('\n') + '\n  ' + code + '</body>\n</html>\n');
      });

  async readConfig(p: string): Promise<{ [key: string]: any; }> {
    try {
      let configContents = await readFile(p, { encoding: 'utf8' });

      if (!configContents) {
        configContents = '{}\n';
        await writeFile(p, configContents, { encoding: 'utf8' });
      }

      return await JSON.parse(configContents);
    } catch (e) {
      throw new ProjectDetailsError('Could not read project file', 'ERR_INVALID_PROJECT_FILE', e);
    }
  }

  const serveIndex = async (req: Request, res: Response) => {
    // respond with the index.html file
    const indexFileName = path.join(options.wwwDir, 'index.html');
    let indexHtml = await readFile(indexFileName, { encoding: 'utf8' });

    indexHtml = injectDevServerScript(indexHtml);

    if (options.livereload) {
      indexHtml = injectLiveReloadScript(indexHtml, options.livereloadPort);
    }

    res.set('Content-Type', 'text/html');
    res.send(indexHtml);
  };

export async function getAndroidSdkToolsVersion(): Promise<string | undefined> {
  const androidHome = await locateSDKHome();

  if (androidHome) {
    try {
      const f = await readFile(path.join(androidHome, 'tools', 'source.properties'), { encoding: 'utf8' });
      return `${await parseSDKVersion(f)} (${androidHome})`;
    } catch (e) {
      if (e.code !== 'ENOENT') {
        throw e;
      }
    }
  }
}

export async function createDevServerHandler(options: DevServerOptions): Promise<RequestHandler> {
  const devServerConfig = {
    consolelogs: options.consolelogs,
    wsPort: options.devPort,
  };

  const devServerJs = await readFile(path.join(__dirname, '..', '..', 'assets', 'dev-server.js'), { encoding: 'utf8' });

  return (req, res) => {
    res.set('Content-Type', 'application/javascript');

    res.send(
      `window.Ionic = window.Ionic || {}; window.Ionic.DevServerConfig = ${JSON.stringify(devServerConfig)};\n\n` +
      `${devServerJs}`.trim()
    );
  };
}

export async function validatePrivateKey(keyPath: string): Promise<void> {
  try {
    await stat(keyPath);
  } catch (e) {
    if (e.code === 'ENOENT') {
      throw ERROR_SSH_MISSING_PRIVKEY;
    }

    throw e;
  }

  const f = await readFile(keyPath, { encoding: 'utf8' });
  const lines = f.split('\n');

  if (!lines[0].match(/^\-{5}BEGIN [A-Z]+ PRIVATE KEY\-{5}$/)) {
    throw ERROR_SSH_INVALID_PRIVKEY;
  }
}

  async uploadSourcemap(sourcemap: APIResponseSuccess, file: string) {
    const { createRequest } = await import('../../lib/utils/http');

    const sm = sourcemap as any;

    const fileData = await readFile(file, { encoding: 'utf8' });
    const sourcemapPost = sm.data.sourcemap_post;

    const { req } = await createRequest('POST', sourcemapPost.url, this.env.config.getHTTPConfig());

    req
      .field(sourcemapPost.fields)
      .field('file', fileData);

    const res = await req;

    if (res.status !== 204) {
      throw new FatalException(`Unexpected status code from AWS: ${res.status}`);
    }
  }

  protected async getSuccessHtml(): Promise<string> {
    const p = path.resolve(ASSETS_DIRECTORY, 'sso', 'success', 'index.html');
    const contents = await readFile(p, { encoding: 'utf8' });

    return contents;
  }