No functional changes so far.

No tests broke. This is a functional change but very much a simple and
basic transformation.

All tests succeed. This is a wrapper implementation, like for printVersions.

Under similar terms as the previous ones. Tests passing.

There are failing tests that I isolated in a spec2 folder.
- develop-spec seems like it "mocks out" the resolution of the Promise,
causing some tests to fail
- stars-spec explodes with a "trying to reopen HTTP port" error,
probably some cleanup section couldn't run
- test-spec mocks I/O of processes and for some reason, the
tests won't produce the right output
- unpublish-spec fails at the unpublishing itself,
there is a lot of mocking but the failure looks too legit nevertheless
- upgrade-spec first times out and then dies with the "HTTP port" error, like stars-spec

It seems that install-spec was the one that didn't close the server, causing the remaining
tests using a server to break.

And the polishment of the corresponding test which passes now. 🎉
getRepositoryUrl has a true resolve-reject interface, the rest always resolves,
mostly wrapped by the Promise constructor

All the previous tests pass still. Finally, a function that could be changed to
an async flow, rather than just wrapped into a Promise.
The calls have been modified appropriately.

Tests still pass. It's a really thin Promise wrapper on the existing code.

Tiny file, tiny wrapper, tests pass.

Tests pass, tiny wrapper of tiny command

A bit fatter wrapping for a bit fatter command. Tests are passing.

Tests passing, trivial wrapper used.

Tests passing. Trivial wrapper added.

Tests passing. Two of the three methods could immediately be turned into async 🎉

It was so small that it was easier to do than not do.
Only install.js was modified which is currently not tested.

Tests still passing. The main change is that printVersions in apm-cli could be promisified
as a result.

Tests passing. run could be asyncified right away. I still want to tackle
generateFromTemplate which is ugly.

Tests still passing.

Tests still passing. It was so banal that it could be asyncified right away.
As a positive side effect, linkPackage in develop.js doesn't have to be wrapped
with the Promise constructor anymore.

This one has no tests but the code is banal.

All tests passing, some code could be asyncified again.
It's important to note that some errors might slip through the commands but
the API of run is not stable yet either way.

Tests passing. init.js could also see some refinement.

All tests passing, this one was banal.

this was a large one but also rather educational one.
Tests still passing, although their amount is worryingly low so probably
some further testing will be necessary.

Tests passing. It's a rather small change but the run method could
be asyncified at least.

There was a mistake in the porting, and perhaps it's good to make it more
apparent that auth.saveToken really wraps an async call

It really wraps a Promise that has async operations in it; it probably shouldn't
throw a synchronous error either.

There were no tests for this and currently I couldn't get keytar working in
my environment so I'm relying on common sense.

All tests still passing (which actually means not all is lost with Install either,
because it uses Install under the hood in some cases).
Some of the commands had to be wrapped with the Promise constructor,
others could be redone as async (as a result). :)

It simply didn't wait for the callback to run... 🤦‍♂️
The tests are passing, some trivial promisification done in the command.

All tests passing. Some synchronization has been fixed and converTheme got
nicer and better in init.js.

All tests passing.
This is not strictly an async-related change because this utility is mostly a modified forEach
but the code could be improved nevertheless.
Maybe it can even be eliminated eventually.

Tests are still passing. This async.eachSeries is quite bothering, it would be
great to eliminate it eventually.

All tests passing.
This could be plain sequential code as well but it's more convenient to stick
to the async interface.

Test passes after the sufficient modification. The code is basically what
we can expect as final state overall.

Tests passing but a properly executed unstar operation throws a weird
error (just like now) because the backend sends an unexpected HTTP status code.
The code itself is much like star.js.

Tests still passing. This means that docs.js could be completely asyncified.

All tests passing. This one is interweaved with config.js and the Command
base class so it's still mostly a trivial Promise wrapper.

All tests still passing. All the related calls have been modified.
There is a reason I didn't hurry to do this... but it will allow for nicer
interfaces. Actually, it already let me keep resolve and reject separate for a longer time.

No interface modifications, just some looks. All tests passing.

All tests still passing.
For the modules where this had an effect and which have already been promisified,
the benefits can already be seen: without changing their interface, their
implementation could be made much more async-like.

upgrade-spec.js has been reclaimed with all tests passing.
Seems like the 'async' package has a nice async-friendly interface already.
I don't quite like how getLatestVersion resolves with no value (undefined)
for HTTP 404 and when the package is already the latest or missing...
but for now, this is the setting that works.

I adapted the test in one case; there is no point in sweating too much over
undefined and null.
Other than that, only refactored files have been modified, and all tests pass.

The situation is desperate but I needed to save my work.

With this modification, the test can be run partially, without breaking
anything else...

At last, ALL tests are passing, with slight undefined vs null modifications! 🥳
That could be reclaimed later on if it really matters.

This command had already been broken on master but hey, if it's part of the
code base, why not at least try to keep superficially up-to-date? :)
All tests passing.

This command is broken on master as well but install.js calls the rebuild
method so I went ahead and asyncified it.
It still doesn't work (I think the problem is related to asar and faulty
resolution of "resource paths") but the tests are still passing.

This is a cosmetic phase of the iterative development. I'm eliminating as
much of callbacks as possible to see what work is left.
All tests passing.

Similar to the last commit. All tests passing.

Similar to the previous two commits. All tests passing.
It seems to me that probably only request.js and login.js are still the old way...

Similar to the previous cosmetic changes. All tests still passing.

Similar to the previous ones. All tests passing.

*without the main user-facing interface because that's deliberately not a Node-style
callback. All tests are passing.

This is the main reason I didn't want to touch Login before. It wasn't as
scary as it first seemed.
All tests passing, the only thing left is the Login command itself.

All tests passing - but tests are too lenient because they don't actually
test the prompt path...
That seems to work, too.
The interface is still unmodified because this was the only command that
had separate error and return value.

Tests (and manual check) passes. Now the command has no special return value,
and getTokenOrLogin calls a method that can have one.

The recent PR pulsar-edit#100 made me want to check this command and I noticed
I messed up at two places to make this work.
Rather obvious fixes for a fortunate catch...

Now that everything is Promise-based (and anything new should also be), it's
pointless to keep an option for classes to avoid wrapping into Promises.
Nothing should be wrapped anymore.

All tests still passing. Some unused code and leftover wrapping removed.

Co-authored-by: confused_techie <dev@lhbasics.com>

Co-authored-by: confused_techie <dev@lhbasics.com>

Co-authored-by: confused_techie <dev@lhbasics.com>