JS script to inhibit sleep when lid is closed not working. File descriptor managing problem or else?

Ok, I was right that the FD was being closed at function end, releasing the inhibit. I couldn't find a way to keep the FD open, but I was able to keep the function running using it asynchronously.

Next step is to integrate this into my extension.

This is the the new code:

/*jshint multistr:true */
/*jshint esnext:true */
/*global imports: true */
/*global global: true */
/*global log: true */
'use strict';

const Gio = imports.gi.Gio;
const GLib = imports.gi.GLib;
const GObject = imports.gi.GObject;
const Mainloop = imports.mainloop;
const Atk = imports.gi.Atk;


const DBusInterface = '<node>
  <interface name="org.freedesktop.login1.Manager">
    <method name="Inhibit">
        <arg type="s" direction="in" />
        <arg type="s" direction="in" />
        <arg type="s" direction="in" />
        <arg type="s" direction="in" />
        <arg type="h" direction="out" />
    </method>
    </interface>
  </node>';

const DBusProxy = Gio.DBusProxy.makeProxyWrapper(DBusInterface);
let proxy = new DBusProxy(
    Gio.DBus.system,
    "org.freedesktop.login1",
    "/org/freedesktop/login1"
);

var inhibitor = {loop:''};

/* Inhibit remote starts the inhibitor asynchronously and locks itself with
   a GLib.MainLoop assigned to inhibitor.loop.
   To release the inhibit just quit the loop at inhibitor.loop
*/
proxy.InhibitRemote('handle-lid-switch', 'lidsleep-inhibitor',
                    'el diego de la gente lo quiere', 'block',
                    (fileDescriptor) => {

                        if (fileDescriptor) {
                            let loop = new GLib.MainLoop(null, false);
                            inhibitor.loop = loop;
                            log("Inhibitor added to array");
                            loop.run();
                            log("Shutting down completed");
                            return;
                        }
                        else {
                            logError("Inhibit returned null");
                            return;
                        }
                    });


/* A ten second timer function */
Promise.timeoutSeconds = function(priority = GLib.PRIORITY_DEFAULT, interval = 10) {
    return new Promise(resolve => GLib.timeout_add_seconds(priority, interval, resolve));
};

/* A function that calls a timer and wait for it to finish. Then, if the arg
   cont is true it releases the inhibit and return false. Otherwise it quits  
   the main loop.
*/
async function asyncCall(cont) {
    try {
      log('Waiting 10 sec');
      await Promise.timeoutSeconds();
      if (cont){
        log('10 sec completed, inhibitor shut down starting');
        inhibitor.loop.quit();
        return !cont;
      } else {
        log('Quitting main loop');
        loop.quit();
        return;
      }
  } catch (e) {
      throw e;
  }
}


let loop = new GLib.MainLoop(null, false);

/* asyncCall is called twice.
   The first run releases the inhibit.
   The second run quits the main loop.
*/
asyncCall(true).
  then(asyncCall);

log("Starting main loop");
loop.run();