wispjs 2.1.3 → 2.1.4

package/dist/wisp_socket/pool.d.ts

@@ -0,0 +1,183 @@
+import { Socket } from "socket.io-client";
+/**
+ * The struct used to define the events that can be sent from the server to the client
+ *
+ * @internal
+ */
+export interface ServerToClientEvents {
+    "error": (message: string) => void;
+    "auth_success": (message: string) => void;
+    "filesearch-results": (data: FilesearchResults) => void;
+    "git-error": (data: string) => void;
+    "git-success": (message?: string) => void;
+    "git-clone": (data: GitCloneData) => void;
+    "git-pull": (data: GitPullData) => void;
+    "console": (message: ConsoleMessage) => void;
+    "initial status": (message: any) => void;
+}
+/**
+ * The struct used to define the events that can be sent from the client to the server
+ *
+ * @internal
+ */
+export interface ClientToServerEvents {
+    "auth": (token: string) => void;
+    "filesearch-start": (query: string) => void;
+    "git-clone": (data: GitCloneData) => void;
+    "git-pull": (data: GitPullData) => void;
+    "send command": (command: string) => void;
+}
+/**
+ * The struct sent from the server containing console messages
+ *
+ * @param type The type of message. Currently unknown what varients exist
+ * @param line The actual content of the console messages
+ *
+ * @internal
+ */
+export interface ConsoleMessage {
+    type: string;
+    line: string;
+}
+/**
+ * Struct used to initiate a Git Clone action
+ *
+ * @param dir The directory to clone into
+ * @param url The HTTPS URL to clone
+ * @param branch The repository branch
+ * @param authkey The authentication key to use when pulling
+ *
+ * @internal
+ */
+export interface GitCloneData {
+    dir: string;
+    url: string;
+    branch: string;
+    authkey?: string | undefined;
+}
+/**
+ * Return struct after finishing a Git Clone action
+ *
+ * @param isPrivate Whether or not the repository is private
+ *
+ * @internal
+ */
+export interface GitCloneResult {
+    isPrivate: boolean;
+}
+/**
+ * Struct used to initiate a Git Pull action
+ *
+ * @param dir The directory to pull
+ * @param authkey The authentication key to use when pulling
+ *
+ * @internal
+ */
+export interface GitPullData {
+    dir: string;
+    authkey?: string;
+}
+/**
+ * Struct returned after a Git Pull action finishes
+ *
+ * @param output The actual output
+ * @param isPrivate Whether or not the repository is private
+ *
+ * @internal
+ */
+export interface GitPullResult {
+    output: string;
+    isPrivate: boolean;
+}
+/**
+ * An individual filesearch result
+ *
+ * @param results How many results are present in the file
+ * @param lines A map of line numbers to their contents. These lines include nearby context of matched lines
+ *
+ * @internal
+ */
+export interface FilesearchFile {
+    results: number;
+    lines: {
+        [key: string]: string;
+    };
+}
+/**
+ * The results of a file search
+ *
+ * @param files A map of file names to matched+context lines within each file
+ * @param tooMany Whether or not there were too many results to display
+ *
+ * @internal
+ */
+export interface FilesearchResults {
+    files: {
+        [key: string]: FilesearchFile;
+    };
+    tooMany: boolean;
+}
+/**
+ * The events that can be sent from the server to the client
+ * @internal
+ */
+export type WispWebsocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+/**
+ * A single worker in the Websocket Pool
+ *
+ * @internal
+ */
+interface PoolWorker {
+    pool: WebsocketPool;
+    socket: WispWebsocket;
+    idx: number;
+    token: string;
+    ready: boolean;
+    logger: {
+        log(...args: any[]): void;
+        error(...args: any[]): void;
+    };
+}
+/**
+ * A single Worker within a {@link WebsocketPool}
+ *
+ * @param pool The pool this worker is a part of
+ *
+ * @internal
+ */
+declare class PoolWorker {
+    constructor(pool: WebsocketPool);
+    available(): boolean;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    run(work: (worker: PoolWorker) => Promise<any>): Promise<any>;
+}
+/**
+ * Struct used to manage a pool of WebSocket workers
+ */
+export interface WebsocketPool {
+    workers: PoolWorker[];
+    token: string;
+    url: string;
+    maxWorkers: number;
+    queue: ((worker: PoolWorker) => Promise<any>)[];
+}
+/**
+ * A pool of {@link PoolWorker}s
+ *
+ * This is used to manage a pool of WebSocket workers that can be used to run tasks in parallel
+ * This alleviates the need to wait for every WebSocket instruction to fully complete before starting another
+ *
+ * @param url The WebSocket URL to connect to
+ * @param token The token to use for WebSocket authentication
+ *
+ * @internal
+ */
+export declare class WebsocketPool {
+    constructor(url: string, token: string);
+    createWorker(): Promise<PoolWorker>;
+    disconnect(): Promise<void>;
+    processQueue(): Promise<any>;
+    run(work: (worker: PoolWorker) => Promise<any>): Promise<any>;
+}
+export {};

package/dist/wisp_socket/pool.js

@@ -0,0 +1,171 @@
+import { io } from "socket.io-client";
+/**
+ * A single Worker within a {@link WebsocketPool}
+ *
+ * @param pool The pool this worker is a part of
+ *
+ * @internal
+ */
+class PoolWorker {
+    constructor(pool) {
+        this.pool = pool;
+        this.ready = false;
+        this.idx = pool.workers.length;
+        this.token = pool.token;
+        this.socket = io(pool.url, {
+            forceNew: true,
+            transports: ["websocket"],
+            addTrailingSlash: true,
+            autoConnect: false
+        });
+        const logPrefix = `[Worker #${this.idx}]`;
+        this.logger = {
+            log: (...args) => console.log(logPrefix, args),
+            error: (...args) => console.error(logPrefix, args),
+        };
+    }
+    available() {
+        return this.ready && this.socket.connected;
+    }
+    connect() {
+        const socket = this.socket;
+        const logger = this.logger;
+        socket.onAnyOutgoing(this.logger.log);
+        logger.log("Connecting to websocket...");
+        return new Promise((resolve, reject) => {
+            let connectedOnce = false;
+            const timeout = setTimeout(() => {
+                if (!connectedOnce) {
+                    logger.error("Socket didn't connect in time");
+                    reject("Connection Timeout");
+                }
+            }, 10000);
+            socket.on("connect", () => {
+                logger.log("Connected to WebSocket");
+                logger.log("Emitting:", "auth", this.token);
+                socket.emit("auth", this.token);
+            });
+            socket.on("error", (reason) => {
+                logger.error(`WebSocket error: ${reason}`);
+            });
+            socket.on("connect_error", (error) => {
+                logger.error(`WebSocket Connect error: ${error.toString()}`);
+                if (!connectedOnce) {
+                    connectedOnce = true;
+                    clearTimeout(timeout);
+                    reject(`Connection error: ${error.toString()}`);
+                }
+            });
+            socket.on("disconnect", (reason) => {
+                logger.log(`Disconnected from WebSocket: ${reason}`);
+            });
+            socket.on("auth_success", () => {
+                logger.log("Auth success");
+                if (!connectedOnce) {
+                    connectedOnce = true;
+                    this.ready = true;
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            socket.connect();
+        });
+    }
+    disconnect() {
+        this.ready = false;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.logger.error("Socket didn't disconnect in time");
+                reject();
+            }, 5000);
+            this.socket.once("disconnect", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.socket.disconnect();
+        });
+    }
+    async run(work) {
+        this.ready = false;
+        // TODO: Verify that a finally is what we want here
+        try {
+            return await work(this);
+        }
+        catch (e) {
+            this.logger.error(e);
+            throw e;
+        }
+        finally {
+            this.ready = true;
+            this.pool.processQueue();
+        }
+    }
+}
+/**
+ * A pool of {@link PoolWorker}s
+ *
+ * This is used to manage a pool of WebSocket workers that can be used to run tasks in parallel
+ * This alleviates the need to wait for every WebSocket instruction to fully complete before starting another
+ *
+ * @param url The WebSocket URL to connect to
+ * @param token The token to use for WebSocket authentication
+ *
+ * @internal
+ */
+export class WebsocketPool {
+    constructor(url, token) {
+        this.maxWorkers = 5;
+        this.token = token;
+        this.url = url;
+        this.workers = [];
+        this.queue = [];
+    }
+    async createWorker() {
+        console.log("Creating a new Pool worker");
+        const worker = new PoolWorker(this);
+        this.workers.push(worker);
+        await worker.connect();
+        return worker;
+    }
+    async disconnect() {
+        await Promise.all(this.workers.map((worker) => worker.disconnect()));
+    }
+    async processQueue() {
+        if (this.queue.length == 0) {
+            return;
+        }
+        const work = this.queue.shift();
+        if (!work) {
+            return;
+        }
+        let worker;
+        if (this.workers.length == 0) {
+            worker = await this.createWorker();
+        }
+        worker = worker || this.workers.find((worker) => worker.available());
+        if (!worker) {
+            if (this.workers.length < this.maxWorkers) {
+                worker = await this.createWorker();
+            }
+            else {
+                return;
+            }
+        }
+        return await worker.run(work);
+    }
+    async run(work) {
+        return new Promise(async (resolve, reject) => {
+            this.queue.push(async (worker) => {
+                try {
+                    const result = await work(worker);
+                    resolve(result);
+                }
+                catch (e) {
+                    worker.logger.error("Failed to run a job!");
+                    reject(e);
+                }
+            });
+            return this.processQueue();
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispjs",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "type": "module",
   "description": "A package for interacting with Wisp-based server panels",
   "main": "dist/wisp.js",

package/.github/workflows/release.yml

@@ -1,72 +0,0 @@
-name: Deploy
-
-on:
-  workflow_dispatch:
-    inputs:
-      version_tag:
-        description: "Version tag for the package"
-        required: true
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 18
-
-      - name: Update package version
-        run: |
-          version=${{ inputs.version_tag }}
-          sed -i "s/\"version\": \".*\"/\"version\": \"$version\"/" package.json
-
-      - name: Install packages
-        run: |
-          npm ci
-
-      - name: Build
-        run: |
-          npm run build
-
-      - name: Generate Docs
-        run: |
-          npm run build-docs
-          mv docs ../docs_wip
-
-      - name: Remove Non-distributables
-        run: |
-          rm .gitignore
-          rm tsconfig.json
-          rm wisp.ts
-          rm -rf wisp_api wisp_socket .github
-
-      - name: Publish
-        uses: JS-DevTools/npm-publish@v3
-        with:
-          token: ${{ secrets.NPM_PUBLISH_TOKEN }}
-
-      - name: Configure Git User
-        run: |
-          git config user.name github-actions
-          git config user.email github-actions@github.com
-
-      - name: Push package version change
-        run: |
-          git add package.json
-          git commit -m "Update package.json version to: ${{ inputs.version_tag }}" && \
-            git push --force-with-lease origin main || \
-            echo "Version tag unchanaged"
-
-          git tag "${{ inputs.version_tag }}"
-          git push --tags
-
-      - name: Publish Docs
-        run: |
-          rm -rf ./* ,/.*
-
-          mv ../docs_wip docs
-          git add .
-          git commit -m "Update Docs for version: ${{ inputs.version_tag }}"
-          git push --force origin HEAD:docs

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-
-    "outDir": "./dist/",
-    "declaration": true,
-
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-
-    "strict": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node"
-  },
-  "include": ["*.ts"],
-  "exclude": ["node_modules"]
-}
-

package/wisp_api/apis/allocations.ts

@@ -1,71 +0,0 @@
-import { WispAPICore } from "./index";
-import type { PaginationData } from "./index";
-
-/**
- * An Allocation object
- *
- * @internal
- */
-export interface Allocation {
-  object: "allocation";
-  attributes: {
-    id: number;
-    /** Whether or not this Allocation is the primary one for the Server */
-    primary: boolean;
-    ip: string;
-    port: number;
-  }
-}
-
-/**
- * The response object from the GetAllocations call
- *
- * @remarks
- * Used in {@link AllocationsAPI.List}
- *
- * @public
- */
-export interface GetAllocationsResponse {
-  object: "list";
-  data: Allocation[];
-  meta: {
-    pagination: PaginationData;
-  }
-}
-
-/**
- * Handles the listing and updating of a Server's IP/Port Allocations
- *
- * @public
- */
-export class AllocationsAPI {
-  constructor(private core: WispAPICore) {}
-
-
-  /**
-   * Lists all Allocations for the Server
-   *
-   * @public
-   */
-  async List(): Promise<GetAllocationsResponse> {
-    const response = await this.core.makeRequest("GET", "allocations");
-    const data: GetAllocationsResponse = await response.json()
-
-    return data;
-  }
-
-
-  /**
-   * Sets the new primary Allocation for the server
-   *
-   * @param id Allocation ID of the new primary allocation
-   *
-   * @public
-   */
-  async Update(id: string): Promise<Allocation> {
-    const response = await this.core.makeRequest("PUT", `allocations/${id}`);
-    const data: Allocation = await response.json()
-
-    return data;
-  }
-}

package/wisp_api/apis/audit_log.ts

@@ -1,81 +0,0 @@
-import { WispAPICore } from "./index";
-import type { PaginationData } from "./index";
-
-/**
- * Device information
- *
- * @example
- * ```json
- * {
- *    "city_name": "Seattle",
- *    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0",
- *    "country_name": "US",
- *    "country_iso_code": "US"
- * }
- * ```
- *
- * @internal
- */
-export interface Device {
-  city_name: string;
-  user_agent: string;
-  country_name: string;
-  country_iso_code: string;
-}
-
-// TODO: Fully define the audit log type
-/**
- * An Audit Log struct
- *
- * @internal
- */
-export interface AuditLog {
-  object: "audit_log";
-  attributes: {
-    action: string;
-    subaction: string;
-    device: Device | undefined;
-    metadata: any;
-    created_at: string;
-  }
-}
-
-/**
- * The respones object from the GetAuditLogs call
- *
- * @remarks
- * Used in {@link AuditLogsAPI.List}
- *
- * @public
- */
-export interface GetAuditLogsResponse {
-  object: "list";
-  data: AuditLog[];
-  meta: {
-    pagination: PaginationData;
-  }
-}
-
-
-/**
- * Interface that handles Listing of all Audit Logs
- *
- * @public
- */
-export class AuditLogsAPI {
-  constructor(private core: WispAPICore) {}
-
-
-  // TODO: Handle pagination
-  /**
-   * List all Audit Log events for the server
-   *
-   * @public
-   */
-  async List(): Promise<GetAuditLogsResponse> {
-    const response = await this.core.makeRequest("GET", "audit-logs");
-    const data: GetAuditLogsResponse = await response.json();
-
-    return data;
-  }
-}

package/wisp_api/apis/databases.ts

@@ -1,80 +0,0 @@
-import { WispAPICore } from "./index";
-import type { PaginationData } from "./index";
-
-export interface DatabaseRelationship {
-  object: "database_host";
-  attributes: {
-    id: number;
-    name: string;
-    host: string;
-    port: number;
-    phpmyadmin_url: string | null;
-  }
-}
-
-export interface Database {
-  object: "database";
-  attributes: {
-    id: number;
-    name: string;
-    remote: string;
-    username: string;
-    password: string;
-    relationships: DatabaseRelationship[];
-  }
-}
-export interface GetDatabasesResponse {
-  object: "list";
-  data: Database[];
-  meta: {
-    pagination: PaginationData;
-  }
-}
-
-/**
- * Handles Creating, Listing, Updating, and Deleting of Databases for the Server
- *
- * @public
- */
-export class DatabasesAPI {
-  constructor(private core: WispAPICore) {}
-
-  // TODO: Handle Pagination
-  /**
-   * Lists all Databases associated with the Server
-   *
-   * @public
-   */
-  async List(): Promise<GetDatabasesResponse> {
-    const response = await this.core.makeRequest("GET", "databases", { include: "hosts" });
-    const data: GetDatabasesResponse = await response.json();
-
-    return data;
-  }
-
-
-  // TODO: verify response
-  /**
-   * Deletes the Database from the Server
-   *
-   * @param id The ID of the Backup
-   *
-   * @public
-   */
-  async Delete(id: string): Promise<Response> {
-    return await this.core.makeRequest("DELETE", `databases/${id}`);
-  }
-
-
-  // TODO: Verify response
-  /**
-   * Rotates the password for the Backup
-   *
-   * @param id The ID of the Backup
-   *
-   * @public
-   */
-  async RotatePassword(id: string): Promise<Response> {
-    return await this.core.makeRequest("POST", `databases/${id}`);
-  }
-}

package/wisp_api/apis/fastdl.ts

@@ -1,22 +0,0 @@
-import { WispAPICore } from "./index";
-
-/**
- * Handles the syncing of the FastDL feature
- *
- * @public
- */
-export class FastDLAPI {
-  constructor(private core: WispAPICore) {}
-
-  /**
-   * Begins a FastDL Sync for the server
-   *
-   * @remarks
-   * ⚠️  If a Sync is already in progress, this function will succeed even though the process will fail.
-   *
-   * @public
-   */
-  async Sync(): Promise<void> {
-    await this.core.makeRequest("POST", "fastdl");
-  }
-}