@jsprismarine/prismarine
Version:
Dedicated Minecraft Bedrock Edition server written in TypeScript
187 lines (186 loc) • 22 kB
JavaScript
import playerToggleOperatorEvent from "../events/player/PlayerToggleOperatorEvent.es.js";
import { withCwd } from "../utils/cwd.es.js";
import fs from "node:fs";
import { parseJSON5 } from "confbox";
import { PlayerNotFoundError } from "@jsprismarine/errors";
//#region src/permission/PermissionManager.ts
var PERMISSION_FILE_NAME = "permissions.json";
var OPS_FILE_NAME = "ops.json";
/**
* Permission manager.
*/
var PermissionManager = class {
server;
ops = /* @__PURE__ */ new Set();
permissions = /* @__PURE__ */ new Map();
defaultPermissions = [];
defaultOperatorPermissions = [];
/**
* Create a new permission manager.
* @param {Server} server - The server instance.
*/
constructor(server) {
this.server = server;
}
/**
* Enable the manager and load all permissions.
* @returns {Promise<void>} A promise that resolves when the manager is enabled.
* @group Lifecycle
*/
async enable() {
await this.parseOps();
await this.parsePermissions();
}
/**
* Signifies that the manager is being disabled and all permissions should be unloaded.
* @returns {Promise<void>} A promise that resolves when the manager is disabled.
* @group Lifecycle
*/
async disable() {
this.ops.clear();
this.permissions.clear();
this.defaultPermissions = [];
}
/**
* Get the default permissions.
* @returns {string[]} The default permissions.
*/
getDefaultPermissions() {
return this.defaultPermissions;
}
/**
* Get a player's permissions.
* @param {Player} player - The player to get permissions for.
* @returns {Promise<string[]>} A promise that resolves with the player's permissions.
*/
async getPermissions(player) {
return [
...this.defaultPermissions,
...this.permissions.get(player.getName()) ?? [],
...player.isOp() ? this.defaultOperatorPermissions : []
];
}
/**
* Set a player's permissions.
*
* @remarks
* This will not be saved to the permissions.json file.
*
* @param {Player} player - The player to set permissions for.
* @param {string[]} [permissions=[]] - The permissions to set.
*/
setPermissions(player, permissions = []) {
this.permissions.set(player.getName(), permissions);
}
async parsePermissions() {
try {
if (!fs.existsSync(withCwd(PERMISSION_FILE_NAME))) {
this.server.getLogger().warn(`Failed to load permissions list!`);
fs.writeFileSync(withCwd(PERMISSION_FILE_NAME), JSON.stringify({
defaultPermissions: [
"minecraft.command.help",
"minecraft.command.list",
"minecraft.command.me",
"jsprismarine.command.plugins",
"jsprismarine.command.version",
"jsprismarine.command.tps"
],
defaultOperatorPermissions: ["*"],
players: [{
name: "filfat",
permissions: ["*"]
}]
}, null, 4));
}
const permissionsObject = parseJSON5((await fs.promises.readFile(withCwd(PERMISSION_FILE_NAME))).toString());
this.defaultPermissions = permissionsObject.defaultPermissions || [];
this.defaultOperatorPermissions = permissionsObject.defaultOperatorPermissions || ["*"];
permissionsObject.players?.map((player) => this.permissions.set(player.name, player.permissions.length <= 0 ? [] : player.permissions));
} catch (error) {
this.server.getLogger().error(error);
throw new Error(`Invalid ${PERMISSION_FILE_NAME} file.`);
}
}
async parseOps() {
try {
if (!fs.existsSync(withCwd(OPS_FILE_NAME))) {
this.server.getLogger().warn(`Failed to load operators list!`);
fs.writeFileSync(withCwd(OPS_FILE_NAME), "[]");
}
parseJSON5((await fs.promises.readFile(withCwd(OPS_FILE_NAME))).toString()).map((op) => this.ops.add(op.name));
} catch (error) {
this.server.getLogger().error(error);
throw new Error(`Invalid ${OPS_FILE_NAME} file.`);
}
}
/**
* Set a player as an operator.
*
* @param {string} username - The player to set as an operator.
* @param {boolean} op - Whether the player should be an operator.
* @returns {Promise<boolean>} A promise that resolves with a boolean indicating whether the operation was successful.
*/
async setOp(username, op) {
const target = this.server.getSessionManager().getPlayerByExactName(username);
if (!target) throw new PlayerNotFoundError(username);
const event = new playerToggleOperatorEvent(target, op);
this.server.post(["playerToggleOperator", event]);
if (event.isCancelled()) return false;
await target.getNetworkSession().sendAvailableCommands();
if (op) this.ops.add(username);
else this.ops.delete(username);
try {
await fs.promises.writeFile(withCwd(OPS_FILE_NAME), JSON.stringify(Array.from(this.ops.values()).map((name) => ({
name,
level: 4
})), null, 4));
await target.sendSettings();
return true;
} catch {
return false;
}
}
/**
* Check if a player is an operator.
*
* @param {string} username - The player to check.
* @returns {boolean} Whether the player is an operator.
*/
isOp(username) {
return this.ops.has(username);
}
/**
* Check if a player can execute a command.
*
* @param {Player} executer - The player to check.
* @returns {object} An object with an execute method that takes a permission string and returns whether the player can execute the command.
*/
can(executer) {
const execute = (permission) => {
if (!executer) throw new Error(`Executer can't be undefined or null`);
if (!permission) return true;
if (executer.isConsole()) return true;
if (executer.isOp()) return true;
if (executer.getPermissions().includes(permission)) return true;
if (executer.getPermissions().includes("*")) return true;
const split = permission.split(".");
let scope = "";
for (const action of split) {
if (scope) scope = `${scope}.${action}`;
else scope = action;
if (executer.getPermissions().includes(scope)) return true;
if (executer.getPermissions().includes(`${scope}.*`)) return true;
}
return false;
};
return {
execute,
not: () => {
return { execute: (permission) => !execute(permission) };
}
};
}
};
//#endregion
export { PermissionManager };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"PermissionManager.es.js","names":[],"sources":["../../src/permission/PermissionManager.ts"],"sourcesContent":["import fs from 'node:fs';\n\nimport { parseJSON5 } from 'confbox';\n\nimport { PlayerNotFoundError } from '@jsprismarine/errors';\nimport type { Player, Server, Service } from '../';\nimport { withCwd } from '../';\nimport playerToggleOperatorEvent from '../events/player/PlayerToggleOperatorEvent';\n\ninterface OpType {\n    name: string;\n}\n\nconst PERMISSION_FILE_NAME = 'permissions.json';\nconst OPS_FILE_NAME = 'ops.json';\n\n/**\n * Permission manager.\n */\nexport class PermissionManager implements Service {\n    private readonly server: Server;\n    private readonly ops: Set<string> = new Set();\n    private readonly permissions: Map<string, string[]> = new Map();\n    private defaultPermissions: string[] = [];\n    private defaultOperatorPermissions: string[] = [];\n\n    /**\n     * Create a new permission manager.\n     * @param {Server} server - The server instance.\n     */\n    public constructor(server: Server) {\n        this.server = server;\n    }\n\n    /**\n     * Enable the manager and load all permissions.\n     * @returns {Promise<void>} A promise that resolves when the manager is enabled.\n     * @group Lifecycle\n     */\n    public async enable(): Promise<void> {\n        await this.parseOps();\n        await this.parsePermissions();\n    }\n\n    /**\n     * Signifies that the manager is being disabled and all permissions should be unloaded.\n     * @returns {Promise<void>} A promise that resolves when the manager is disabled.\n     * @group Lifecycle\n     */\n    public async disable(): Promise<void> {\n        this.ops.clear();\n        this.permissions.clear();\n        this.defaultPermissions = [];\n    }\n\n    /**\n     * Get the default permissions.\n     * @returns {string[]} The default permissions.\n     */\n    public getDefaultPermissions(): string[] {\n        return this.defaultPermissions;\n    }\n\n    /**\n     * Get a player's permissions.\n     * @param {Player} player - The player to get permissions for.\n     * @returns {Promise<string[]>} A promise that resolves with the player's permissions.\n     */\n    public async getPermissions(player: Player): Promise<string[]> {\n        return [\n            ...this.defaultPermissions,\n            ...(this.permissions.get(player.getName()) ?? []),\n            ...(player.isOp() ? this.defaultOperatorPermissions : [])\n        ];\n    }\n\n    /**\n     * Set a player's permissions.\n     *\n     * @remarks\n     * This will not be saved to the permissions.json file.\n     *\n     * @param {Player} player - The player to set permissions for.\n     * @param {string[]} [permissions=[]] - The permissions to set.\n     */\n    public setPermissions(player: Player, permissions: string[] = []) {\n        this.permissions.set(player.getName(), permissions);\n    }\n\n    private async parsePermissions(): Promise<void> {\n        try {\n            if (!fs.existsSync(withCwd(PERMISSION_FILE_NAME))) {\n                this.server.getLogger().warn(`Failed to load permissions list!`);\n                fs.writeFileSync(\n                    // FIXME: This overwrites comments in the file.\n                    withCwd(PERMISSION_FILE_NAME),\n                    JSON.stringify(\n                        {\n                            defaultPermissions: [\n                                'minecraft.command.help',\n                                'minecraft.command.list',\n                                'minecraft.command.me',\n                                'jsprismarine.command.plugins',\n                                'jsprismarine.command.version',\n                                'jsprismarine.command.tps'\n                            ],\n                            defaultOperatorPermissions: ['*'],\n                            players: [\n                                {\n                                    name: 'filfat',\n                                    permissions: ['*']\n                                }\n                            ]\n                        },\n                        null,\n                        4\n                    )\n                );\n            }\n\n            const permissionsObject: Partial<{\n                defaultPermissions: string[];\n                defaultOperatorPermissions: string[];\n                players: Array<{\n                    name: string;\n                    permissions: string[];\n                }>;\n            }> = parseJSON5((await fs.promises.readFile(withCwd(PERMISSION_FILE_NAME))).toString());\n\n            this.defaultPermissions = permissionsObject.defaultPermissions || [];\n            this.defaultOperatorPermissions = permissionsObject.defaultOperatorPermissions || ['*'];\n            permissionsObject.players?.map((player) =>\n                this.permissions.set(player.name, player.permissions.length <= 0 ? [] : player.permissions)\n            );\n        } catch (error: unknown) {\n            this.server.getLogger().error(error);\n            throw new Error(`Invalid ${PERMISSION_FILE_NAME} file.`);\n        }\n    }\n\n    private async parseOps(): Promise<void> {\n        try {\n            if (!fs.existsSync(withCwd(OPS_FILE_NAME))) {\n                this.server.getLogger().warn(`Failed to load operators list!`);\n                fs.writeFileSync(withCwd(OPS_FILE_NAME), '[]');\n            }\n            const ops: OpType[] = parseJSON5((await fs.promises.readFile(withCwd(OPS_FILE_NAME))).toString());\n\n            ops.map((op) => this.ops.add(op.name));\n        } catch (error: unknown) {\n            this.server.getLogger().error(error);\n            throw new Error(`Invalid ${OPS_FILE_NAME} file.`);\n        }\n    }\n\n    /**\n     * Set a player as an operator.\n     *\n     * @param {string} username - The player to set as an operator.\n     * @param {boolean} op - Whether the player should be an operator.\n     * @returns {Promise<boolean>} A promise that resolves with a boolean indicating whether the operation was successful.\n     */\n    public async setOp(username: string, op: boolean): Promise<boolean> {\n        const target = this.server.getSessionManager().getPlayerByExactName(username); // TODO: by name not exact\n        if (!target) throw new PlayerNotFoundError(username);\n        const event = new playerToggleOperatorEvent(target, op);\n        this.server.post(['playerToggleOperator', event]);\n        if (event.isCancelled()) return false;\n\n        await target.getNetworkSession().sendAvailableCommands();\n\n        if (op) this.ops.add(username);\n        else this.ops.delete(username);\n\n        try {\n            await fs.promises.writeFile(\n                // FIXME: This overwrites comments in the file.\n                withCwd(OPS_FILE_NAME),\n                JSON.stringify(\n                    Array.from(this.ops.values()).map((name) => ({\n                        name,\n                        level: 4\n                    })),\n                    null,\n                    4\n                )\n            );\n\n            await target.sendSettings();\n            return true;\n        } catch {\n            return false;\n        }\n    }\n\n    /**\n     * Check if a player is an operator.\n     *\n     * @param {string} username - The player to check.\n     * @returns {boolean} Whether the player is an operator.\n     */\n    public isOp(username: string): boolean {\n        return this.ops.has(username);\n    }\n\n    /**\n     * Check if a player can execute a command.\n     *\n     * @param {Player} executer - The player to check.\n     * @returns {object} An object with an execute method that takes a permission string and returns whether the player can execute the command.\n     */\n    public can(executer?: Player) {\n        const execute = (permission?: string) => {\n            if (!executer) throw new Error(`Executer can't be undefined or null`);\n\n            if (!permission) return true;\n            if (executer.isConsole()) return true;\n            if (executer.isOp()) return true;\n            if (executer.getPermissions().includes(permission)) return true;\n            if (executer.getPermissions().includes('*')) return true;\n\n            const split = permission.split('.');\n            let scope = '';\n            for (const action of split) {\n                if (scope) scope = `${scope}.${action}`;\n                else scope = action;\n\n                if (executer.getPermissions().includes(scope)) return true;\n                if (executer.getPermissions().includes(`${scope}.*`)) return true;\n            }\n\n            return false;\n        };\n\n        return {\n            execute,\n            not: () => {\n                return {\n                    execute: (permission?: string) => !execute(permission)\n                };\n            }\n        };\n    }\n}\n"],"mappings":"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"}