wispjs 2.4.0 → 3.0.1

package/dist/wisp_socket/index.js

@@ -1,5 +1,7 @@
 import stripAnsi from 'strip-ansi';
 import { WebsocketPool } from "./pool.js";
+import { GitSocket } from "./git.js";
+import { FilesystemSocket } from "./filesystem.js";
 /**
  * The primary interface to the Websocket API
  *
@@ -11,6 +13,8 @@ export class WispSocket {
         this.api = api;
         this.ghToken = ghToken;
         this.consoleCallbacks = [];
+        this.Git = new GitSocket(this);
+        this.Filesystem = new FilesystemSocket(this);
     }
     /**
      * Sets a callback to run on the Websocket Info before saving the details.
@@ -43,7 +47,16 @@ export class WispSocket {
         if (!this.url || !this.token) {
             throw new Error("Attempted to create a pool without a URL or token");
         }
-        this.pool = new WebsocketPool(this.url, this.token);
+        // Provider used by the pool to refresh the (short-lived) token when a
+        // worker needs to reconnect.
+        const refreshDetails = async () => {
+            await this.setDetails();
+            return { url: this.url, token: this.token };
+        };
+        // The Origin header is the panel the connection originates from, which
+        // is always the API domain.
+        const origin = `https://${this.api.domain}`;
+        this.pool = new WebsocketPool(this.url, this.token, origin, refreshDetails);
     }
     /**
      * Requests and saves the Websocket details from the API
@@ -58,7 +71,7 @@ export class WispSocket {
             }
             this.url = websocketInfo.url;
             this.token = websocketInfo.token;
-            this.logger.info("Got Websocket Details.", this.url, this.token);
+            this.logger.info(`Got Websocket Details. ${this.url} - ${this.token}`);
         }
         catch (e) {
             this.logger.error(`Failed to get websocket details: ${e}`);
@@ -87,178 +100,112 @@ export class WispSocket {
         }
     }
     /**
-     * Searches all file contents for the given query
+     * Runs a job on an available pool worker, handing it the worker's socket
+     * and logger. Used for event-based flows (e.g. file search) that don't fit
+     * the {@link request} request/response protocol.
      *
-     * @param query The query string to search for
-     * @param timeout How long to wait (in ms) for results before timing out
+     * @param work The job to run; receives the worker and returns a Promise
      *
-     * @public
+     * @internal
      */
-    async filesearch(query, timeout = 10000) {
-        this.logger.info("Running filesearch with: ", query);
+    async runWorker(work) {
         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((resolve, reject) => {
-                const timeoutObj = setTimeout(() => {
-                    socket.off("filesearch-results");
-                    logger.error("Rejected filesearch: 'Timeout'");
-                    reject();
-                }, timeout);
-                socket.once("filesearch-results", (data) => {
-                    clearTimeout(timeoutObj);
-                    resolve(data);
-                });
-                socket.emit("filesearch-start", query);
-            });
-        });
+        return await this.pool.run(work);
     }
     /**
-     * Performs a git pull operation on the given directory
-     *
-     * @param dir The full directory path to perform a pull on
-     * @param timeout In milliseconds, how long to wait before timing out
+     * Generates a short, unique request id for {@link request} correlation.
      *
-     * @public
+     * @internal
      */
-    async gitPull(dir, useAuth = false, timeout = 10000) {
-        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((resolve, reject) => {
-                let isPrivate = false;
-                let finished;
-                const timeoutObj = setTimeout(() => {
-                    logger.error("Rejected gitPull: 'Timeout'");
-                    finished(false, "Timeout");
-                }, timeout);
-                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 {
-                        logger.error("Rejected gitPull:", dir, output);
-                        reject(output);
-                    }
-                    clearTimeout(timeoutObj);
-                };
-                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!");
-                        }
-                        isPrivate = true;
-                        data.authkey = this.ghToken;
-                    }
-                    socket.emit("git-pull", data);
-                };
-                socket.once("git-pull", (data) => {
-                    logger.log(`Updating ${data}`);
-                });
-                socket.once("git-success", (commit) => {
-                    logger.log(`Addon updated to ${commit}`);
-                    if (!commit) {
-                        logger.log("No commit given!");
-                    }
-                    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);
-                    }
-                });
-                sendRequest(useAuth);
-            });
-        });
-        return pullResult;
+    generateReqId() {
+        return Math.random().toString(36).slice(2, 14);
     }
     /**
-     * Clones a new Repo to the given directory
+     * Issues a correlated `fs:request` to the backend and awaits its outcome.
+     *
+     * This is the low-level entry point for the git/filesystem protocol. The
+     * client emits `fs:request` with a JSON-string payload (`{ req, op, ...params }`),
+     * and the backend replies with one of three events, all correlated by `req`
+     * and all carrying a JSON-string `args[0]`:
+     *
+     *   - `fs:result`   — success; resolves with the parsed `data`
+     *   - `fs:error`    — failure; rejects with an {@link FsError} (plus collected `output`)
+     *   - `fs:progress` — streaming stdout/stderr/progress lines (collected for error context)
      *
-     * @param url The HTTPS URL of the repository
-     * @param dir The full path of the directory to clone the repository to
-     * @param branch The branch of the repository to clone
-     * @param timeout In milliseconds, how long to wait before timing out
+     * Typed convenience wrappers live on {@link GitSocket} ({@link WispSocket.Git})
+     * and {@link FilesystemSocket} ({@link WispSocket.Filesystem}); call this
+     * directly for ops that don't have a typed wrapper yet.
+     *
+     * @example
+     * ```js
+     * const status = await wisp.socket.request("git-status", { directory: "/garrysmod/addons/acf-3" })
+     * ```
+     *
+     * @param op The operation name (e.g. `git-pull`, `list`)
+     * @param params Additional payload fields merged into the request (e.g. `{ directory }`)
+     * @param timeout In milliseconds, how long to wait for the result
      *
      * @public
      */
-    async gitClone(url, dir, branch, timeout = 20000) {
+    async request(op, params = {}, timeout = 10000) {
         await this.verifyPool();
         return await this.pool.run((worker) => {
             const socket = worker.socket;
             const logger = worker.logger;
-            logger.log("Running gitClone:", url, dir, branch);
+            const req = this.generateReqId();
+            logger.log(`Running fsRequest: ${op}`, params);
             return new Promise((resolve, reject) => {
-                let isPrivate = false;
-                let finished;
-                const timeoutObj = setTimeout(() => {
-                    logger.error("Rejected gitClone: 'Timeout'");
-                    finished(false, "Timeout");
-                }, timeout);
-                finished = (success, message) => {
-                    socket.removeAllListeners("git-clone");
-                    socket.removeAllListeners("git-error");
-                    socket.removeAllListeners("git-success");
-                    if (success) {
-                        const result = {
-                            isPrivate: isPrivate
-                        };
-                        resolve(result);
+                const progress = [];
+                let resultHandler;
+                let errorHandler;
+                let progressHandler;
+                const parse = (raw) => {
+                    try {
+                        return JSON.parse(raw);
                     }
-                    else {
-                        logger.error("Rejected gitClone:", url, dir, branch, message);
-                        reject(message);
+                    catch {
+                        logger.error(`Failed to parse fs event for ${op}`, raw);
+                        return undefined;
                     }
+                };
+                const cleanup = () => {
+                    socket.off("fs:result", resultHandler);
+                    socket.off("fs:error", errorHandler);
+                    socket.off("fs:progress", progressHandler);
                     clearTimeout(timeoutObj);
                 };
-                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!");
-                        }
-                        isPrivate = true;
-                        data.authkey = this.ghToken;
-                    }
-                    socket.emit("git-clone", data);
+                const timeoutObj = setTimeout(() => {
+                    cleanup();
+                    logger.error(`fsRequest timed out: ${op} (${req})`);
+                    reject(new Error(`fsRequest timed out: ${op}`));
+                }, timeout);
+                progressHandler = (raw) => {
+                    const p = parse(raw);
+                    if (!p || p.req !== req)
+                        return;
+                    const line = p.line ?? "";
+                    progress.push(line);
+                    logger.debug(`[${op}] ${p.kind}: ${line}`);
                 };
-                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 {
-                        logger.log("Error cloning repo:", url, dir, branch, message);
-                        finished(false, message);
-                    }
-                });
-                sendRequest();
+                resultHandler = (raw) => {
+                    const p = parse(raw);
+                    if (!p || p.req !== req)
+                        return;
+                    cleanup();
+                    resolve(p.data);
+                };
+                errorHandler = (raw) => {
+                    const p = parse(raw);
+                    if (!p || p.req !== req)
+                        return;
+                    cleanup();
+                    logger.error(`fsRequest error: ${op} - ${p.code}: ${p.message}`);
+                    reject({ ...p, output: progress.join("\n") });
+                };
+                socket.on("fs:result", resultHandler);
+                socket.on("fs:error", errorHandler);
+                socket.on("fs:progress", progressHandler);
+                socket.emit("fs:request", JSON.stringify({ req, op, ...params }));
             });
         });
     }
@@ -273,9 +220,13 @@ export class WispSocket {
                 const logger = worker.logger;
                 logger.log("Running setupConsoleListener");
                 return new Promise((resolve) => {
-                    worker.socket.on("console", (data) => {
-                        const line = data.line;
+                    const cleanup = () => {
+                        worker.socket.off("console output", handleLine);
+                        worker.socket.off("disconnect", handleDisconnect);
+                    };
+                    const handleLine = (line) => {
                         if (this.consoleCallbacks.length == 0) {
+                            cleanup();
                             return resolve();
                         }
                         this.consoleCallbacks.forEach((callback) => {
@@ -286,7 +237,16 @@ export class WispSocket {
                                 logger.error("Failed to run console callback", e);
                             }
                         });
-                    });
+                    };
+                    const handleDisconnect = () => {
+                        cleanup();
+                        resolve();
+                        if (this.consoleCallbacks.length > 0) {
+                            this.setupConsoleListener();
+                        }
+                    };
+                    worker.socket.on("console output", handleLine);
+                    worker.socket.once("disconnect", handleDisconnect);
                 });
             });
         });
@@ -363,17 +323,16 @@ export class WispSocket {
                 let callback;
                 const timeoutObj = setTimeout(() => {
                     logger.error(`Command timed out current output: '${output}'`);
-                    socket.off("console", callback);
+                    socket.off("console output", callback);
                     logger.log("Rejected sendCommandNonce 'Timeout'", nonce, command);
                     reject("Timeout");
                 }, timeout);
-                callback = (data) => {
-                    const line = data.line;
+                callback = (line) => {
                     const clean = stripAnsi(line);
                     if (clean.startsWith(nonce)) {
                         const message = clean.slice(nonce.length);
                         if (message === "Done.") {
-                            socket.off("console", callback);
+                            socket.off("console output", callback);
                             clearTimeout(timeoutObj);
                             resolve(output);
                         }
@@ -383,7 +342,7 @@ export class WispSocket {
                         }
                     }
                 };
-                socket.on("console", callback);
+                socket.on("console output", callback);
                 socket.emit("send command", command);
             });
         });