How to use the kefir.fromPromise function in kefir

const toObs = (ret: E2EExec): Observable => {
  // Normalize other values to Observables.
  if (ret == null) {
    return Kefir.constant('');
  }

  if (isPromise(ret)) {
    return Kefir.fromPromise(ret);
  }

  return ret;
};

const
    _ = require('lodash'),
    fs = require('fs'),
    path = require('path'),
    util = require('util'),
    kefir = require('kefir'),
    Kubemote = require('kubemotelib');

let
    client = new Kubemote(Kubemote.CONFIGURATION_FILE()),
    outputFile = fs.createWriteStream('dump.jsonl');   // .jsonl is a valid extension for "json lines" file (not valid JSON)

let deploymentEventStream = kefir
    .fromPromise(client.watchDeploymentList())
    .flatMap(()=> kefir.fromEvents(client, 'watch'))        //"ADDED", "MODIFIED", "DELETED", "ERROR"
    .onValue((event)=> {
        let payload = { timestamp: Date.now(), event };
        outputFile.write([JSON.stringify(payload), "\n"].join(''));
    });

endpointUrl: '',
        prepareImages: !imageQuery ? undefined : elementsInfo => {
          return prepareImages(elementsInfo, imageQuery);
        },
        imagePropertyUris: imageIris,
        // should we specify it in config?
        // GET allows for more caching, but does not run well with huge data sets
        queryMethod: SparqlQueryMethod.POST,
        acceptBlankNodes: true,
      };
      const repositories = this.getRepositories();
      const createRDFStorage = provisionQuery !== undefined;
      this.dataProvider = config.getDataProvider(options, repositories, createRDFStorage);

      this.cancellation.map(Kefir.combine([
        Kefir.fromPromise(this.setLayout()),
        this.parsedMetadata,
      ])).observe({
        error: configurationError => this.setState({configurationError}),
      });
    }
  }

.flatMapLatest(url => {
        if (D.isBrowser) {
          window.history.pushState({}, "", url)
        }
        let routeResult = router.doroute(url)
        return K.fromPromise(routeResult.payload().then(app => {
          return {...routeResult, app, url}
        }))
      })
      .map(({mask, params, app, url}) => {

.flatMapLatest(([beetsWebURL, artist, album]) => {
    return K.fromPromise(getTrackList(beetsWebURL, album, artist));
  })
  .toProperty(() => []);

var parsedData = urlStrings.flatMap(function (x) {
    return K.fromPromise(request({encoding: null, uri: x}));
  })
        .map(zlib.unzipSync)

    .flatMapConcat(_ => K
      .fromPromise(A.get(`/api/users/${params.id}/`))
      .map(resp => resp.data.models[params.id])
    )

const createPrismUpdateStream = (props: Props): Observable =>
    Kefir.fromPromise(Promise.all([
        Prism.setTheme(props.theme),
        Prism.togglePlugin('show-invisibles', props.invisibles === 'on')
    ]))
        .ignoreValues()
        .setName('prismUpdate$');

    }).flatMapConcat(form => K
      .fromPromise(A.put(`/api/posts/${params.id}/`, form))
      .map(resp => resp.data.model)
    )