@expcluster/permission-groups 7.0.1

package/index.ts

@@ -0,0 +1,183 @@
+import * as lib from "@clusterio/lib";
+import * as messages from "./messages";
+
+declare module "@clusterio/lib" {
+	export interface InstanceConfigFields {
+		"exp_groups.sync_mode": "enabled" | "disabled" | "bidirectional"
+	}
+	export interface ControllerConfigFields {
+	}
+}
+
+// Group permissions
+
+lib.definePermission({
+	name: "exp_groups.group.get",
+	title: "Get Groups",
+	description: "Retrieve a specific Factorio permission group by ID.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.group.list",
+	title: "List Groups",
+	description: "List all Factorio permission groups.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.group.subscribe",
+	title: "Subscribe to Group Updates",
+	description: "Receive updates when Factorio permission groups change.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.group.create",
+	title: "Create Groups",
+	description: "Create new Factorio permission groups.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.group.update",
+	title: "Update Groups",
+	description: "Modify existing Factorio permission groups.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.group.delete",
+	title: "Delete Groups",
+	description: "Delete Factorio permission groups.",
+	grantByDefault: false,
+});
+
+// Assignment permissions
+
+lib.definePermission({
+	name: "exp_groups.assignment.get",
+	title: "Get Assignments",
+	description: "Retrieve a specific manual group assignment for a player.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.assignment.list",
+	title: "List Assignments",
+	description: "List all manual group assignments.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.assignment.subscribe",
+	title: "Subscribe to Assignment Updates",
+	description: "Receive updates when manual group assignments change.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.assignment.create",
+	title: "Create Assignments",
+	description: "Manually assign players to groups, overriding role mappings.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.assignment.update",
+	title: "Update Assignments",
+	description: "Modify existing manual group assignments.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.assignment.delete",
+	title: "Delete Assignments",
+	description: "Remove manual group assignments.",
+	grantByDefault: false,
+});
+
+// Role mapping permissions
+
+lib.definePermission({
+	name: "exp_groups.role_mapping.get",
+	title: "Get Role Mappings",
+	description: "Retrieve a specific role mapping rule.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.role_mapping.list",
+	title: "List Role Mappings",
+	description: "List all role mapping rules.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.role_mapping.subscribe",
+	title: "Subscribe to Role Mapping Updates",
+	description: "Receive updates when role mapping rules change.",
+	grantByDefault: true,
+});
+lib.definePermission({
+	name: "exp_groups.role_mapping.create",
+	title: "Create Role Mappings",
+	description: "Create rules that map user roles to Factorio permission groups.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.role_mapping.update",
+	title: "Update Role Mappings",
+	description: "Modify existing role mapping rules.",
+	grantByDefault: false,
+});
+lib.definePermission({
+	name: "exp_groups.role_mapping.delete",
+	title: "Delete Role Mappings",
+	description: "Delete role mapping rules.",
+	grantByDefault: false,
+});
+
+export const plugin: lib.PluginDeclaration = {
+	name: "exp_groups",
+	title: "ExpGaming - Permission Groups",
+	description: "Clusterio plugin providing syncing of permission groups",
+
+	features: [
+		"SavePatching",
+		"ScriptCommands",
+	],
+
+	messages: [
+		messages.GroupUpdatedEvent,
+		messages.ManualAssignmentUpdatedEvent,
+		messages.ResolvedAssignmentUpdatedEvent,
+		messages.RoleMappingUpdatedEvent,
+
+		messages.GroupCreateRequest,
+		messages.GroupUpdateRequest,
+		messages.GroupDeleteRequest,
+		messages.GroupGetRequest,
+		messages.GroupListRequest,
+
+		messages.AssignmentCreateRequest,
+		messages.AssignmentUpdateRequest,
+		messages.AssignmentDeleteRequest,
+		messages.AssignmentGetRequest,
+		messages.AssignmentListRequest,
+
+		messages.RoleMappingCreateRequest,
+		messages.RoleMappingUpdateRequest,
+		messages.RoleMappingDeleteRequest,
+		messages.RoleMappingGetRequest,
+		messages.RoleMappingListRequest,
+	],
+
+	instanceEntrypoint: "./dist/node/instance",
+	instanceConfigFields: {
+		"exp_groups.sync_mode": {
+			description: "Synchronize permission groups with the controller",
+			type: "string",
+			enum: ["disabled", "enabled", "bidirectional"],
+			initialValue: "bidirectional",
+		},
+	},
+
+	controllerEntrypoint: "./dist/node/controller",
+	controllerConfigFields: {
+	},
+
+	webEntrypoint: "./web",
+	routes: [
+		"/permission_groups",
+		"/permission_groups/:id/view",
+	]
+};

package/instance.ts

@@ -0,0 +1,171 @@
+import { BaseInstancePlugin } from "@clusterio/host";
+import * as lib from "@clusterio/lib";
+import * as messages from "./messages";
+
+export type IpcGroupUpdated = {
+	group_name: string,
+	group_id: number | undefined,
+	permissions: { is_blacklist: boolean, permissions: string[] | undefined },
+};
+
+export type IpcGroupDeleted = {
+	group_name: string,
+	group_id: number | undefined,
+};
+
+export type IpcPlayerAssignments = {
+	assignments: Record<string, number>,
+};
+
+export class InstancePlugin extends BaseInstancePlugin {
+    // Once only, don't send permissions for these groups
+    // This is used for groups created on this instance that only need the controller generated id
+    skipSendingPermissions = new Set<string>(); 
+    // This is used for groups updated / deleted on this instance to stop cycles
+    skipSendingUpdate = new Set<number>(); 
+    // Track known online players so that we only apply assignment updates for them
+    onlinePlayers = new Set<string>();
+
+    async init() {
+        this.instance.handle(messages.GroupUpdatedEvent, this.handleGroupUpdatedEvent.bind(this));
+        this.instance.handle(messages.ResolvedAssignmentUpdatedEvent, this.handleResolvedAssignmentUpdatedEvent.bind(this));
+        this.instance.server.handle(`exp_group:group_updated`, this.handleGroupUpdatedIPC.bind(this))
+        this.instance.server.handle(`exp_group:group_deleted`, this.handleGroupDeletedIPC.bind(this))
+        this.instance.server.handle(`exp_group:player_assignments`, this.handlePlayerAssignmentsIPC.bind(this))
+    }
+
+    async onInstanceConfigFieldChanged(field: string, curr: unknown, prev: unknown) {
+        switch(field) {
+            case "exp_groups.sync_mode":
+                await this.luaSetEmitEvents(curr == "bidirectional")
+                break;
+        }
+    }
+
+    async onStart() {
+        // We use Date.now() because we need to manually initialise the groups on the lua side
+        await this.instance.sendTo("controller", new lib.SubscriptionRequest(
+            `exp_groups:${messages.GroupUpdatedEvent.name}`, "subscribe", Date.now()
+        ));
+        const groups = await this.instance.sendTo("controller", new messages.GroupListRequest())
+        await this.luaSendInitialGroups(groups);
+        await this.luaSetEmitEvents(this.instance.config.get("exp_groups.sync_mode") == "bidirectional")
+    }
+
+    async onPlayerEvent(event: lib.PlayerEvent) {
+        switch(event.type) {
+            case "join":
+                this.onlinePlayers.add(event.name);
+                await this.subscribePlayerAssignment(event.name);
+                break;
+            case "leave":
+                this.onlinePlayers.delete(event.name);
+                await this.unsubscribePlayerAssignment(event.name);
+                break;
+        }
+    }
+
+    async handleGroupUpdatedEvent(event: messages.GroupUpdatedEvent) {
+        for (const group of event.updates) {
+            await this.luaSendGroupUpdate(group);
+        }
+    }
+
+    async handleResolvedAssignmentUpdatedEvent(event: messages.ManualAssignmentUpdatedEvent) {
+        for (const assignment of event.updates) {
+            if (this.onlinePlayers.has(assignment.name)) {
+                await this.luaSendAssignmentUpdate(assignment);
+            }
+        }
+    }
+
+    async handleGroupUpdatedIPC(event: IpcGroupUpdated) {
+        const permissions = new messages.GroupPermissions(
+            event.permissions.is_blacklist,
+            event.permissions.permissions ?? [],
+        )
+
+        if (event.group_id === undefined) {
+            this.skipSendingPermissions.add(event.group_name);
+            await this.instance.sendTo("controller",
+                new messages.GroupCreateRequest(event.group_name, permissions),
+            );
+        } else {
+            this.skipSendingUpdate.add(event.group_id);
+            await this.instance.sendTo("controller", new messages.GroupUpdateRequest(
+                new messages.GroupRecord(event.group_id, event.group_name, permissions),
+            ));
+        }
+    }
+
+    async handleGroupDeletedIPC(event: IpcGroupDeleted) {
+        if (event.group_id === undefined) {
+            return;
+        }
+        this.skipSendingUpdate.add(event.group_id);
+        await this.instance.sendTo("controller", new messages.GroupDeleteRequest(event.group_id));
+    }
+
+    async handlePlayerAssignmentsIPC(event: IpcPlayerAssignments) {
+        await Promise.all(
+            Object.entries(event.assignments).map(([playerName, groupId]) =>
+                this.instance.sendTo("controller",
+                    new messages.AssignmentUpdateRequest(new messages.AssignmentRecord(playerName, groupId)),
+                )
+            )
+        );
+    }
+
+    async subscribePlayerAssignment(playerName: string) {
+        await this.instance.sendTo("controller", new lib.SubscriptionRequest(
+            `exp_groups:${messages.ResolvedAssignmentUpdatedEvent.name}`, "subscribe", 0, lib.SubscriptionFilters.fromShorthand(playerName)
+        ));
+    }
+
+    async unsubscribePlayerAssignment(playerName: string) {
+        await this.instance.sendTo("controller", new lib.SubscriptionRequest(
+            `exp_groups:${messages.ResolvedAssignmentUpdatedEvent.name}`, "unsubscribe", 0, lib.SubscriptionFilters.fromShorthand(playerName)
+        ));
+    }
+
+    async luaSendInitialGroups(groups: messages.GroupRecord[]) {
+        if (this.instance.config.get("exp_groups.sync_mode") === "disabled") {
+            return;
+        }
+        await this.luaSend("initialise_groups", groups);
+    }
+
+    async luaSendGroupUpdate(group: messages.GroupRecord) {
+        if (this.instance.config.get("exp_groups.sync_mode") === "disabled") {
+            return;
+        }
+
+        if (this.skipSendingUpdate.has(group.id)) {
+            this.skipSendingUpdate.delete(group.id);
+            return;
+        }
+
+        const json = group.toJSON();
+        if (this.skipSendingPermissions.has(group.name)) {
+            this.skipSendingPermissions.delete(group.name);
+            delete (json as any).permissions;
+        }
+
+        await this.luaSend("receive_group_update", json);
+    }
+
+    async luaSendAssignmentUpdate(assignment: messages.AssignmentRecord) {
+        if (this.instance.config.get("exp_groups.sync_mode") === "disabled") {
+            return;
+        }
+        await this.luaSend("receive_assignment_update", assignment);
+    }
+
+    async luaSetEmitEvents(emitEvents: boolean) {
+        await this.luaSend("set_emit_events", emitEvents);
+    }
+
+    async luaSend(receiver: string, json: any) {
+        await this.instance.sendRcon(`/sc exp_groups.${receiver}(helpers.json_to_table[=[${JSON.stringify(json)}]=])`, true)
+    }
+}