How to use the bluebird function in bluebird

await service.walkDir(relativePath, true, async (itemPath, isDir) => {
      const pathOnServer = path.join(tmpFolder, itemPath);
      if (isDir) {
        await fs.mkdir(pathOnServer);
      } else {
        const readStream = await service.createReadStream(itemPath, {autoDestroy: true });
        const writeStream = fs.createWriteStream(pathOnServer, {autoClose: true});
        promises.push(new B((resolve) => writeStream.on('close', resolve)));
        readStream.pipe(writeStream);
      }
    });
    try {

addWarcsFromWCreate ({col, warcs, lastUpdated, seed}) {
    console.log('addfs warcs to col', col, warcs, lastUpdated, seed)
    let opts = {
      cwd: settings.get('warcs')
    }
    let exec = S(settings.get('pywb.reindexCol')).template({col}).s
    let updateWho = {colName: col}
    let colSeedIdQ = {_id: `${col}-${seed.url}`}
    return new Promise((resolve, reject) =>
      execute(exec, opts).then(({stdout, stderr}) =>
        this.getColSize(col).then(size => {
          console.log(stdout, stderr)
          let theUpdateCol = {$inc: {numArchives: 1}, $set: {size, lastUpdated}}
          console.log(theUpdateCol)
          return updateSingle(this.collections, updateWho, theUpdateCol, updateSingleOpts).then((updatedCol) =>
            findOne(this.colSeeds, colSeedIdQ).then(colSeed => {
              let findA = {
                $where () {
                  return this.forCol === col
                }
              }
              let theUpdateColSeed
              if (foundSeedChecker(colSeed)) {
                theUpdateColSeed = {
                  $set: {lastUpdated},

var getSelectedAudioDeviceOSX = () => {
    return new Promise((resolve, reject) => {
        var exePath = path.join(process.cwd(), 'resources/bin/driver/', process.platform, 'audiodevice')
        var child = childProcess.execFile(exePath, ["output"], {}, function (error, stdout, stderr) {
            var device = stdout.trim().split("\n").join("");
            resolve(device);
        }.bind(this));
    });
}

resize(image, _config) {
    let config = _config || {};

    return new Promise((resolve, reject) => {
      this.getProvider()(image)
        .resize(config.width || 200, config.height, config.direction || '>')
        .setFormat(config.format || 'jpg')
        .toBuffer((error, buffer) => error ? reject(error) : resolve(buffer));
    });
  }

getDescription(image) {
    return new Promise((resolve, reject) => {
      this.getProvider()(image).identify('%[IPTC:2:120]', (error, metadata) => error ? reject(error) : resolve(metadata.trimRight()));
    });
  }

profileExists() {
    return new Promise((resolve) => {
      fs.statAsync(this._profilePath)
        .then(() => resolve(true))
        .catch({ code: 'ENOENT' }, () => resolve(false));
    });
  }

wemFind (message, query) {
    return new Promise((resolve, reject) => {
      this.db.find(query, (err, docs) => {
        if (err) {
          reject(new dbErrors.DBErrorReport(err, message))
        } else {
          resolve(docs)
        }
      })
    })
  }

function getOAuthRequestToken (containerRef) {
  return Rx.Observable.fromPromise(new Promise((resolve, reject) => {
    const args = JSON.parse(decodeURIComponent(window.location.hash.slice(1)))
    const force_login = args['force_login'] || false
    let authUrl = `https://api.twitter.com/oauth/authenticate?force_login=${force_login.toString()};oauth_token=`
    let oauth = new OAuth(
        'https://api.twitter.com/oauth/request_token',
        'https://api.twitter.com/oauth/access_token',
        args.key,
        args.secret,
        '1.0A',
        null,
        'HMAC-SHA1'
      )

    oauth.getOAuthRequestToken((error, oauth_token, oauth_token_secret, results) => {
      if (error) {
        reject(error)

function performRequest(method, args, options, test, appRef, errorStr) {
  return new Promise((resolve, reject) => {
    if ( options && !(options instanceof Object) ) {
      reject(new TypeError(_('ERR_ARGUMENT_FMT', 'VFS::' + method, 'options', 'Object', typeof options)));
      return;
    }

    const mountpoint = MountManager.getModuleFromPath(test);
    if ( !mountpoint ) {
      reject(new Error(_('ERR_VFSMODULE_NOT_FOUND_FMT', test)));
      return;
    }

    requestWrapper(mountpoint, method, args, options, appRef).then(resolve).catch(reject);
  });
}

function readFile(file) {
  const name = file.name;

  return new Promise(resolve => {
    const reader = new FileReader();
    reader.onload = (e) => resolve({name, content: e.target.result});
    reader.readAsText(file);
  });
}