wispjs 2.1.3 → 2.1.4

package/{wisp_socket/index.ts → dist/wisp_socket/index.js}

@@ -1,54 +1,16 @@
 import { WebsocketPool } from "./pool.js";
-import { ConsoleMessage, FilesearchResults } from "./pool";
-import { GitPullData, GitPullResult } from "./pool.js";
-import { GitCloneData, GitCloneResult } from "./pool.js";
-
-import type { WispAPI } from "../wisp_api/index.js";
-
-
-/**
- * The Websocket information returned from the API
- *
- * @param token The token to use when authenticating with the `auth` command in the Websocket
- * @param url The actual URL of the Websocket
- *
- * @internal
- */
-export interface WebsocketInfo {
-    token: string;
-    url: string;
-}
-
-
-export type WebsocketDetailsPreprocessor = (info: WebsocketInfo) => void;
-
-
-export interface WispSocket {
-    pool: WebsocketPool;
-    logger: any;
-    api: WispAPI;
-    url: string | undefined;
-    token: string | undefined;
-    ghToken: string | undefined;
-    consoleCallbacks: ((message: string) => void)[];
-    detailsPreprocessor: WebsocketDetailsPreprocessor | undefined;
-}
-
-
 /**
  * The primary interface to the Websocket API
  *
  * @internal
  */
 export class WispSocket {
-    constructor(logger: any, api: any, ghToken: string | undefined) {
-        this.logger = logger
-        this.api = api
-        this.ghToken = ghToken
-        this.consoleCallbacks = []
+    constructor(logger, api, ghToken) {
+        this.logger = logger;
+        this.api = api;
+        this.ghToken = ghToken;
+        this.consoleCallbacks = [];
     }
-
-
     /**
      * Sets a callback to run on the Websocket Info before saving the details.
      *
@@ -67,11 +29,9 @@ export class WispSocket {
      *
      * @public
      */
-    setWebsocketDetailsPreprocessor(preprocessor: WebsocketDetailsPreprocessor) {
+    setWebsocketDetailsPreprocessor(preprocessor) {
         this.detailsPreprocessor = preprocessor;
     }
-
-
     /**
      * Creates a new Websocket Pool
      *
@@ -80,13 +40,10 @@ export class WispSocket {
      */
     createPool() {
         if (!this.url || !this.token) {
-            throw new Error("Attempted to create a pool without a URL or token")
+            throw new Error("Attempted to create a pool without a URL or token");
         }
-
-        this.pool = new WebsocketPool(this.url, this.token)
+        this.pool = new WebsocketPool(this.url, this.token);
     }
-
-
     /**
      * Requests and saves the Websocket details from the API
      *
@@ -94,22 +51,19 @@ export class WispSocket {
      */
     async setDetails() {
         try {
-            const websocketInfo: WebsocketInfo = await this.api.Servers.GetWebsocketDetails()
+            const websocketInfo = await this.api.Servers.GetWebsocketDetails();
             if (this.detailsPreprocessor) {
                 this.detailsPreprocessor(websocketInfo);
             }
-
-            this.url = websocketInfo.url
-            this.token = websocketInfo.token
-
-            this.logger.info("Got Websocket Details.", this.url, this.token)
-        } catch(e) {
-            this.logger.error(`Failed to get websocket details: ${e}`)
-            throw(e)
+            this.url = websocketInfo.url;
+            this.token = websocketInfo.token;
+            this.logger.info("Got Websocket Details.", this.url, this.token);
+        }
+        catch (e) {
+            this.logger.error(`Failed to get websocket details: ${e}`);
+            throw (e);
         }
     }
-
-
     /**
      * Disconnects from the websocket
      *
@@ -117,11 +71,9 @@ export class WispSocket {
      */
     async disconnect() {
         if (this.pool) {
-            await this.pool.disconnect()
+            await this.pool.disconnect();
         }
     }
-
-
     /**
      * Verifies that the pool is created and ready to use
      *
@@ -129,12 +81,10 @@ export class WispSocket {
      */
     async verifyPool() {
         if (!this.pool) {
-            await this.setDetails()
-            this.createPool()
+            await this.setDetails();
+            this.createPool();
         }
     }
-
-
     /**
      * Searches all file contents for the given query
      *
@@ -142,38 +92,27 @@ export class WispSocket {
      *
      * @public
      */
-    async filesearch(query: string): Promise<FilesearchResults> {
-        this.logger.info("Running filesearch with: ", query)
-        await this.verifyPool()
-
+    async filesearch(query) {
+        this.logger.info("Running filesearch with: ", query);
+        await this.verifyPool();
         return await this.pool.run((worker) => {
-            const socket = worker.socket
-            const logger = worker.logger
-            logger.log("Running filesearch:", query)
-
-            return new Promise<FilesearchResults>((resolve, reject) => {
-                let done = false
-
+            const socket = worker.socket;
+            const logger = worker.logger;
+            logger.log("Running filesearch:", query);
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    socket.off("filesearch-results");
+                    logger.error("Rejected filesearch: 'Timeout'");
+                    reject();
+                }, 10000);
                 socket.once("filesearch-results", (data) => {
-                    done = true
-                    resolve(data)
-                })
-
-                socket.emit("filesearch-start", query)
-
-                // This uses a longer timeout because filesearch can take a while
-                setTimeout(() => {
-                    if (!done) {
-                        socket.off("filesearch-results")
-                        logger.error("Rejected filesearch: 'Timeout'")
-                        reject()
-                    }
-                }, 10000)
-            })
-        })
+                    clearTimeout(timeout);
+                    resolve(data);
+                });
+                socket.emit("filesearch-start", query);
+            });
+        });
     }
-
-
     /**
      * Performs a git pull operation on the given directory
      *
@@ -181,83 +120,67 @@ export class WispSocket {
      *
      * @public
      */
-    async gitPull(dir: string, useAuth: boolean = false) {
-        await this.verifyPool()
-
+    async gitPull(dir, useAuth = false) {
+        await this.verifyPool();
         const pullResult = await this.pool.run((worker) => {
             const socket = worker.socket;
             const logger = worker.logger;
             logger.log("Running gitPull:", dir);
-
-            return new Promise<GitPullResult>((resolve, reject) => {
-                let isPrivate = false
-
-                const finished = (success: boolean, output: string) => {
-                    socket.removeAllListeners("git-pull")
-                    socket.removeAllListeners("git-error")
-                    socket.removeAllListeners("git-success")
-
-                    const result: GitPullResult = {
+            return new Promise((resolve, reject) => {
+                let isPrivate = false;
+                const finished = (success, output) => {
+                    socket.removeAllListeners("git-pull");
+                    socket.removeAllListeners("git-error");
+                    socket.removeAllListeners("git-success");
+                    const result = {
                         output: output,
                         isPrivate: isPrivate
-                    }
-
+                    };
                     if (success) {
-                        resolve(result)
-                    } else {
+                        resolve(result);
+                    }
+                    else {
                         logger.error("Rejected gitPull:", dir, output);
-                        reject(output)
+                        reject(output);
                     }
-                }
-
-                const sendRequest = (includeAuth: boolean = false) => {
-                    const data: GitPullData = { dir: dir }
-
+                };
+                const sendRequest = (includeAuth = false) => {
+                    const data = { dir: dir };
                     if (includeAuth) {
                         if (!this.ghToken) {
-                            logger.error("No GitHub token set, can't authenticate")
-                            return finished(false, "Authentication is required, but no GitHub token was set. Can't pull!")
+                            logger.error("No GitHub token set, can't authenticate");
+                            return finished(false, "Authentication is required, but no GitHub token was set. Can't pull!");
                         }
-
-                        isPrivate = true
-                        data.authkey = this.ghToken
+                        isPrivate = true;
+                        data.authkey = this.ghToken;
                     }
-
-                    socket.emit("git-pull", data)
-                }
-
+                    socket.emit("git-pull", data);
+                };
                 socket.once("git-pull", (data) => {
-                    logger.log(`Updating ${data}`)
+                    logger.log(`Updating ${data}`);
                 });
-
                 socket.once("git-success", (commit) => {
-                    logger.log(`Addon updated to ${commit}`)
-
+                    logger.log(`Addon updated to ${commit}`);
                     if (!commit) {
-                        logger.log("No commit given!")
+                        logger.log("No commit given!");
                     }
-
-                    finished(true, commit || "")
+                    finished(true, commit || "");
                 });
-
                 socket.on("git-error", (message) => {
                     if (message === "Remote authentication required but no callback set") {
-                        logger.log(`Remote authentication required, trying again with authkey: ${dir}`)
-                        sendRequest(true)
-                    } else {
-                        logger.log(`Error updating addon: ${message}`)
-                        finished(false, message)
+                        logger.log(`Remote authentication required, trying again with authkey: ${dir}`);
+                        sendRequest(true);
+                    }
+                    else {
+                        logger.log(`Error updating addon: ${message}`);
+                        finished(false, message);
                     }
-                })
-
-                sendRequest(useAuth)
-            })
-        })
-
-        return pullResult
+                });
+                sendRequest(useAuth);
+            });
+        });
+        return pullResult;
     }
-
-
     /**
      * Clones a new Repo to the given directory
      *
@@ -267,75 +190,62 @@ export class WispSocket {
      *
      * @public
      */
-    async gitClone(url: string, dir: string, branch: string) {
-        await this.verifyPool()
-
+    async gitClone(url, dir, branch) {
+        await this.verifyPool();
         return await this.pool.run((worker) => {
             const socket = worker.socket;
             const logger = worker.logger;
             logger.log("Running gitClone:", url, dir, branch);
-
-            return new Promise<GitCloneResult>((resolve, reject) => {
+            return new Promise((resolve, reject) => {
                 let isPrivate = false;
-
-                const finished = (success: boolean, message?: string) => {
+                const finished = (success, message) => {
                     socket.removeAllListeners("git-clone");
                     socket.removeAllListeners("git-error");
                     socket.removeAllListeners("git-success");
-
                     if (success) {
-                        const result: GitCloneResult = {
+                        const result = {
                             isPrivate: isPrivate
-                        }
-
+                        };
                         resolve(result);
-                    } else {
+                    }
+                    else {
                         logger.error("Rejected gitClone:", url, dir, branch, message);
                         reject(message);
                     }
-                }
-
-                const sendRequest = (includeAuth: boolean = false) => {
-                    const data: GitCloneData = { dir: dir, url: url, branch: branch };
-
+                };
+                const sendRequest = (includeAuth = false) => {
+                    const data = { dir: dir, url: url, branch: branch };
                     if (includeAuth) {
                         if (!this.ghToken) {
-                            logger.error("No GitHub token set, can't authenticate")
-                            return finished(false, "Authentication is required, but no GitHub token was set. Can't clone!")
+                            logger.error("No GitHub token set, can't authenticate");
+                            return finished(false, "Authentication is required, but no GitHub token was set. Can't clone!");
                         }
-
                         isPrivate = true;
                         data.authkey = this.ghToken;
                     }
-
                     socket.emit("git-clone", data);
-                }
-
+                };
                 socket.once("git-clone", (data) => {
                     logger.log(`Cloning ${data}`);
                 });
-
                 socket.once("git-success", () => {
                     logger.log("Project successfully cloned");
                     finished(true);
                 });
-
                 socket.on("git-error", (message) => {
                     if (message === "Remote authentication required but no callback set") {
                         logger.log(`Remote authentication required, trying again with authkey: ${dir}`);
                         sendRequest(true);
-                    } else {
+                    }
+                    else {
                         logger.log("Error cloning repo:", url, dir, branch, message);
                         finished(false, message);
                     }
                 });
-
                 sendRequest();
             });
         });
     }
-
-
     /**
      * Sets up the console listener worker
      *
@@ -346,29 +256,25 @@ export class WispSocket {
             this.pool.run((worker) => {
                 const logger = worker.logger;
                 logger.log("Running setupConsoleListener");
-
-                return new Promise<void>((resolve) => {
-                    worker.socket.on("console", (data: ConsoleMessage) => {
+                return new Promise((resolve) => {
+                    worker.socket.on("console", (data) => {
                         const line = data.line;
-
                         if (this.consoleCallbacks.length == 0) {
                             return resolve();
                         }
-
                         this.consoleCallbacks.forEach((callback) => {
                             try {
                                 callback(line);
-                            } catch(e) {
+                            }
+                            catch (e) {
                                 logger.error("Failed to run console callback", e);
                             }
                         });
                     });
                 });
             });
-        })
+        });
     }
-
-
     /**
      * Adds a new callback that will run any time a console message is rececived
      *
@@ -376,15 +282,12 @@ export class WispSocket {
      *
      * @public
      */
-    addConsoleListener(callback: (message: string) => void) {
+    addConsoleListener(callback) {
         if (this.consoleCallbacks.length == 0) {
             this.setupConsoleListener();
         }
-
         this.consoleCallbacks.push(callback);
     }
-
-
     /**
      * Removes a previously added console message callback
      *
@@ -392,14 +295,13 @@ export class WispSocket {
      *
      * @public
      */
-    removeConsoleListener(callback: (message: string) => void) {
-        const index = this.consoleCallbacks.indexOf(callback)
-        if (index == -1) { return }
-
-        this.consoleCallbacks.splice(index, 1)
+    removeConsoleListener(callback) {
+        const index = this.consoleCallbacks.indexOf(callback);
+        if (index == -1) {
+            return;
+        }
+        this.consoleCallbacks.splice(index, 1);
     }
-
-
     /**
      * Sends a command to the server and then waits until output with the given prefix is seen in a console message
      *
@@ -434,46 +336,38 @@ export class WispSocket {
      *
      * @public
      */
-    async sendCommandNonce(nonce: string, command: string, timeout: number = 1000) {
-        await this.verifyPool()
-
+    async sendCommandNonce(nonce, command, timeout = 1000) {
+        await this.verifyPool();
         return await this.pool.run((worker) => {
-            const socket = worker.socket
-            const logger = worker.logger
-            logger.log("Running sendCommandNonce: ", nonce, command)
-
-            return new Promise<string>((resolve: Function, reject: Function) => {
-                let timeoutObj: NodeJS.Timeout
-                let callback: (data: ConsoleMessage) => void;
-
-                let output = ""
-
-                callback = (data: ConsoleMessage) => {
-                    const line = data.line
-                    if (line.startsWith(nonce)) {
-                        const message = line.slice(nonce.length)
-
-                        if (message === "Done.") {
-                            socket.off("console", callback)
-                            clearTimeout(timeoutObj)
-
-                            resolve(output)
-                        } else {
-                            output += message
-                            timeoutObj.refresh()
-                        }
-                    }
-                }
-
-                socket.on("console", callback)
-                socket.emit("send command", command)
-
-                timeoutObj = setTimeout(() => {
+            const socket = worker.socket;
+            const logger = worker.logger;
+            logger.log("Running sendCommandNonce: ", nonce, command);
+            return new Promise((resolve, reject) => {
+                let output = "";
+                let callback;
+                const timeoutObj = setTimeout(() => {
                     logger.error(`Command timed out current output: '${output}'`);
                     socket.off("console", callback);
-                    logger.log("Rejected sendCommandNonce 'Timeout'", nonce, command)
+                    logger.log("Rejected sendCommandNonce 'Timeout'", nonce, command);
                     reject("Timeout");
                 }, timeout);
+                callback = (data) => {
+                    const line = data.line;
+                    if (line.startsWith(nonce)) {
+                        const message = line.slice(nonce.length);
+                        if (message === "Done.") {
+                            socket.off("console", callback);
+                            clearTimeout(timeoutObj);
+                            resolve(output);
+                        }
+                        else {
+                            output += message;
+                            timeoutObj.refresh();
+                        }
+                    }
+                };
+                socket.on("console", callback);
+                socket.emit("send command", command);
             });
         });
     }