@voltro/plugin-gm 0.0.0-stage → 0.88.0

package/dist/action.js

@@ -0,0 +1,3 @@
+// src/action.ts
+var e = (e) => e;
+export { e as defineGmAction };

package/dist/builtins.js

@@ -0,0 +1,348 @@
+import { defineGmAction as e } from "./action.js";
+import { Effect as t, Schema as n } from "effect";
+import { systemSubject as r } from "@voltro/protocol";
+// src/builtins.ts
+var i = n.NonEmptyString.pipe(n.check(n.isMaxLength(120))), a = n.String.pipe(n.check(n.isPattern(/^[1-9][0-9]{0,18}$/))), o = (e) => n.Struct({
+	playerId: i,
+	currency: e.currencies ? n.Literals(e.currencies) : n.NonEmptyString,
+	amount: a
+}), s = n.Struct({
+	txId: n.String,
+	currency: n.String,
+	amount: n.String
+}), c = r("gm"), l = (n, r, i, a) => e({
+	id: r.id ?? a.id,
+	title: r.title ?? a.title,
+	risk: r.risk ?? "sensitive",
+	input: o(r),
+	output: s,
+	target: (e) => e.playerId,
+	execute: (e, a) => {
+		let o = {
+			kind: "wallet",
+			ownerKind: "player",
+			ownerId: e.playerId
+		}, s = {
+			kind: "system",
+			id: r.systemAccount
+		};
+		return t.suspend(() => n.economy.service().transfer(c, {
+			tenantId: a.tenantId,
+			requestId: a.requestId,
+			currency: e.currency,
+			amount: e.amount,
+			from: i === "grant" ? s : o,
+			to: i === "grant" ? o : s,
+			reason: "gm." + i,
+			ref: {
+				kind: "gm-request",
+				id: a.requestId
+			}
+		})).pipe(t.map((e) => ({
+			txId: e.txId,
+			currency: e.currency,
+			amount: e.amount
+		})));
+	}
+}), u = (e, t) => l(e, t, "grant", {
+	id: "economy.grant",
+	title: "Grant currency"
+}), d = (e, t) => l(e, t, "revoke", {
+	id: "economy.revoke",
+	title: "Revoke currency"
+}), f = 864e5, p = n.Struct({
+	sanctionId: n.String,
+	until: n.NullOr(n.Number)
+}), m = n.Struct({
+	playerId: i,
+	publicReason: n.NonEmptyString.pipe(n.check(n.isMaxLength(500))),
+	durationMs: n.optional(n.NullOr(n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+		minimum: 1,
+		maximum: 3650 * f
+	}))))),
+	appealable: n.optional(n.Boolean)
+}), h = (n, r, i, a) => e({
+	id: i.id ?? a.id,
+	title: i.title ?? a.title,
+	risk: i.risk ?? a.risk,
+	input: m,
+	output: p,
+	target: (e) => e.playerId,
+	execute: (e, i) => t.suspend(() => n.sanctions.operator().issue({
+		tenantId: i.tenantId,
+		operatorId: i.requesterId
+	}, {
+		requestId: i.requestId,
+		targetId: e.playerId,
+		kind: r,
+		durationMs: e.durationMs ?? null,
+		reason: i.reason,
+		publicReason: e.publicReason,
+		...e.appealable === void 0 ? {} : { appealable: e.appealable }
+	})).pipe(t.map((e) => ({
+		sanctionId: e.id,
+		until: e.until
+	})))
+}), g = (e, t = {}) => h(e, "ban", t, {
+	id: "sanctions.ban",
+	title: "Ban player",
+	risk: "sensitive"
+}), _ = (e, t = {}) => h(e, "mute", t, {
+	id: "sanctions.mute",
+	title: "Mute player",
+	risk: "routine"
+}), v = n.Struct({ kicked: n.Number }), y = (r, i = {}) => e({
+	id: i.id ?? "rooms.kick",
+	title: i.title ?? "Kick from room",
+	risk: i.risk ?? "routine",
+	input: n.Struct({
+		roomId: n.NonEmptyString.pipe(n.check(n.isMaxLength(191))),
+		playerId: n.NonEmptyString.pipe(n.check(n.isMaxLength(191))),
+		publicReason: n.optional(n.String.pipe(n.check(n.isMaxLength(200))))
+	}),
+	output: v,
+	target: (e) => e.playerId,
+	execute: (e, n) => t.suspend(() => r.moderation.kick({
+		tenantId: n.tenantId,
+		roomId: e.roomId,
+		subjectId: e.playerId,
+		reason: e.publicReason ?? ""
+	})).pipe(t.map((e) => ({ kicked: e.kicked })))
+}), b = n.Struct({
+	rooms: n.Number,
+	kicked: n.Number
+}), x = (r, i = {}) => e({
+	id: i.id ?? "rooms.closeAll",
+	title: i.title ?? "Close all rooms",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({ publicReason: n.String.pipe(n.check(n.isMaxLength(200))) }),
+	output: b,
+	execute: (e, n) => {
+		let i = (a, o, s) => t.suspend(() => r.moderation.closeAll({
+			tenantId: n.tenantId,
+			reason: e.publicReason,
+			...a === null ? {} : { after: a }
+		})).pipe(t.flatMap((e) => {
+			let n = {
+				rooms: o.rooms + e.rooms,
+				kicked: o.kicked + e.kicked
+			};
+			return e.next === null || s <= 1 ? t.succeed(n) : i(e.next, n, s - 1);
+		}));
+		return i(null, {
+			rooms: 0,
+			kicked: 0
+		}, 64);
+	}
+}), S = n.Struct({
+	key: n.String,
+	enabled: n.Boolean,
+	previous: n.Boolean
+}), C = (r, i = {}) => e({
+	id: i.id ?? "flags.toggle",
+	title: i.title ?? "Switch a feature on or off",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		key: i.keys ? n.Literals(i.keys) : n.NonEmptyString.pipe(n.check(n.isMaxLength(120))),
+		enabled: n.Boolean
+	}),
+	output: S,
+	execute: (e, n) => t.suspend(() => r.toggle({
+		key: e.key,
+		enabled: e.enabled,
+		actor: n.requesterId
+	})).pipe(t.map((e) => ({
+		key: e.key,
+		enabled: e.enabled,
+		previous: e.previous
+	})))
+}), w = n.Struct({
+	windowId: n.String,
+	state: n.String
+}), T = n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+	minimum: 0,
+	maximum: 864e13
+}))), E = (e) => t.suspend(() => {
+	let n = e.maintenance?.();
+	return n ? t.succeed(n) : t.fail(/* @__PURE__ */ Error("Maintenance is not installed"));
+}), D = (r, i = {}) => e({
+	id: i.id ?? "maintenance.schedule",
+	title: i.title ?? "Schedule maintenance",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		from: T,
+		until: T,
+		drainBy: T,
+		messageKey: n.String.pipe(n.check(n.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/)))
+	}),
+	output: w,
+	execute: (e, n) => E(r).pipe(t.flatMap((t) => t.schedule(c, n.tenantId, {
+		requestId: n.requestId,
+		from: e.from,
+		until: e.until,
+		drainBy: e.drainBy,
+		messageKey: e.messageKey
+	})), t.map((e) => ({
+		windowId: e.id,
+		state: e.state
+	})))
+}), O = (r, i = {}) => e({
+	id: i.id ?? "maintenance.cancel",
+	title: i.title ?? "Cancel maintenance",
+	risk: i.risk ?? "routine",
+	input: n.Struct({ windowId: n.NonEmptyString.pipe(n.check(n.isMaxLength(120))) }),
+	output: w,
+	execute: (e, n) => E(r).pipe(t.flatMap((t) => t.cancel(c, n.tenantId, {
+		requestId: n.requestId,
+		windowId: e.windowId
+	})), t.map((e) => ({
+		windowId: e.id,
+		state: e.state
+	})))
+}), k = n.Struct({
+	key: n.String,
+	json: n.String
+}), A = (r, i = {}) => e({
+	id: i.id ?? "config.set",
+	title: i.title ?? "Change a config value",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		key: i.keys ? n.Literals(i.keys) : n.NonEmptyString.pipe(n.check(n.isMaxLength(120))),
+		json: n.String.pipe(n.check(n.isMinLength(1)), n.check(n.isMaxLength(16384)))
+	}),
+	output: k,
+	execute: (e, n) => t.suspend(() => {
+		let i = r.setConfig;
+		if (!i) return t.fail(/* @__PURE__ */ Error("Config is not installed"));
+		let a;
+		try {
+			a = JSON.parse(e.json);
+		} catch {
+			return t.fail({ code: "invalid_value" });
+		}
+		return i({
+			key: e.key,
+			value: a,
+			actor: n.requesterId
+		}).pipe(t.map((e) => ({
+			key: e.key,
+			json: JSON.stringify(e.value)
+		})));
+	})
+}), j = n.Struct({
+	phase: n.String,
+	champion: n.NullOr(n.String),
+	unresolvedDisputes: n.Number
+}), M = n.NonEmptyString.pipe(n.check(n.isMaxLength(120))), N = (r, i = {}) => e({
+	id: i.id ?? "tournaments.resolve",
+	title: i.title ?? "Decide a tournament dispute",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		tournamentId: M,
+		disputeId: M,
+		winnerId: n.NonEmptyString.pipe(n.check(n.isMaxLength(120)))
+	}),
+	output: j,
+	target: (e) => e.winnerId,
+	execute: (e, n) => t.suspend(() => r.leaderboards.tournaments().resolve(c, {
+		tenantId: n.tenantId,
+		tournamentId: e.tournamentId
+	}, {
+		disputeId: e.disputeId,
+		resolutionId: n.requestId,
+		winnerId: e.winnerId
+	})).pipe(t.map((e) => ({
+		phase: e.phase,
+		champion: e.champion,
+		unresolvedDisputes: e.unresolvedDisputes
+	})))
+}), P = (r, i = {}) => e({
+	id: i.id ?? "leagues.assign",
+	title: i.title ?? "Place a player in a league division",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		playerId: n.NonEmptyString.pipe(n.check(n.isMaxLength(256))),
+		league: n.NonEmptyString.pipe(n.check(n.isMaxLength(120))),
+		division: n.NonEmptyString.pipe(n.check(n.isMaxLength(256)))
+	}),
+	output: n.Struct({
+		league: n.String,
+		division: n.String
+	}),
+	target: (e) => e.playerId,
+	execute: (e, n) => t.suspend(() => r.leaderboards.service().assignLeague(c, {
+		tenantId: n.tenantId,
+		league: e.league,
+		ownerId: e.playerId,
+		division: e.division
+	}))
+}), F = n.Int.pipe(n.check(n.isBetween({
+	minimum: -2147483648,
+	maximum: 2147483647
+}))), I = (r, i = {}) => e({
+	id: i.id ?? "geometry.rollback",
+	title: i.title ?? "Undo a player's building in one chunk",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		roomId: n.NonEmptyString.pipe(n.check(n.isMaxLength(191))),
+		playerId: n.NonEmptyString.pipe(n.check(n.isMaxLength(191))),
+		playerKind: n.optional(n.Literals(["user", "guest"])),
+		cx: F,
+		cy: F,
+		cz: n.optional(F)
+	}),
+	output: n.Struct({ rolledBack: n.Literal(!0) }),
+	target: (e) => e.playerId,
+	execute: (e, n) => t.suspend(() => {
+		let i = r.moderation.rollbackGeometry;
+		return i ? i({
+			tenantId: n.tenantId,
+			roomId: e.roomId,
+			request: {
+				cx: e.cx,
+				cy: e.cy,
+				...e.cz === void 0 ? {} : { cz: e.cz },
+				target: {
+					id: e.playerId,
+					kind: e.playerKind ?? "user"
+				},
+				requestId: n.requestId
+			}
+		}, {
+			type: "user",
+			id: n.requesterId,
+			tenantId: n.tenantId
+		}).pipe(t.as({ rolledBack: !0 })) : t.fail(/* @__PURE__ */ Error("Geometry rollback is not installed"));
+	})
+}), L = (r, i = {}) => e({
+	id: i.id ?? "geometry.reset",
+	title: i.title ?? "Reset one chunk to its built-in version",
+	risk: i.risk ?? "sensitive",
+	input: n.Struct({
+		roomId: n.NonEmptyString.pipe(n.check(n.isMaxLength(191))),
+		cx: F,
+		cy: F,
+		cz: n.optional(F)
+	}),
+	output: n.Struct({ reset: n.Literal(!0) }),
+	target: (e) => e.roomId,
+	execute: (e, n) => t.suspend(() => {
+		let i = r.moderation.rollbackGeometry;
+		return i ? i({
+			tenantId: n.tenantId,
+			roomId: e.roomId,
+			request: {
+				cx: e.cx,
+				cy: e.cy,
+				...e.cz === void 0 ? {} : { cz: e.cz },
+				target: null,
+				requestId: n.requestId
+			}
+		}, {
+			type: "user",
+			id: n.requesterId,
+			tenantId: n.tenantId
+		}).pipe(t.as({ reset: !0 })) : t.fail(/* @__PURE__ */ Error("Geometry rollback is not installed"));
+	})
+});
+export { A as configSet, u as economyGrant, d as economyRevoke, C as flagsToggle, L as geometryReset, I as geometryRollback, P as leaguesAssign, O as maintenanceCancel, D as maintenanceSchedule, x as roomsCloseAll, y as roomsKick, g as sanctionsBan, _ as sanctionsMute, N as tournamentsResolve };

package/dist/contract.js

@@ -0,0 +1,28 @@
+import { Schema as e } from "effect";
+// src/contract.ts
+var t = "_voltro_gm_requests", n = [
+	"pending",
+	"approved",
+	"executed",
+	"rejected"
+], r = ["routine", "sensitive"], i = e.Number, a = e.Struct({
+	id: e.String,
+	actionId: e.String,
+	state: e.Literals(n),
+	targetId: e.NullOr(e.String),
+	input: e.Unknown,
+	output: e.NullOr(e.Unknown),
+	reason: e.String,
+	ticket: e.NullOr(e.String),
+	requesterId: e.NullOr(e.String),
+	approverId: e.NullOr(e.String),
+	createdAt: i,
+	decidedAt: e.NullOr(i),
+	executedAt: e.NullOr(i)
+}), o = e.Struct({
+	id: e.String,
+	title: e.String,
+	risk: e.Literals(r),
+	input: e.Unknown
+});
+export { r as ACTION_RISKS, o as GmActionInfoSchema, a as GmRequestSchema, t as REQUESTS_TABLE, n as REQUEST_STATES };

package/dist/entities.js

@@ -0,0 +1,21 @@
+import { REQUESTS_TABLE as e, REQUEST_STATES as t } from "./contract.js";
+import { id as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+// src/entities.ts
+var s = () => a().maxLength(256).externalId().sensitive("pii"), c = () => a().maxLength(256).externalId().sensitive("pii"), l = i(e, {
+	id: n({ prefix: "gmreq" }),
+	tenantId: s(),
+	actionId: a().maxLength(128).safe(),
+	state: a().oneOf(t).safe(),
+	targetId: c().nullable(),
+	input: r().sensitive("pii"),
+	output: r().nullable().sensitive("pii"),
+	reason: a().sensitive("pii"),
+	ticket: a().maxLength(256).nullable().sensitive("pii"),
+	requesterId: c().nullable(),
+	approverId: c().nullable(),
+	digest: a().maxLength(64).serverOnly(),
+	createdAt: o().safe(),
+	decidedAt: o().nullable().safe(),
+	executedAt: o().nullable().safe()
+}).index(["tenantId", "state"]).index(["tenantId", "targetId"]).index(["tenantId", "requesterId"]), u = [l];
+export { l as gmRequestsTable, u as gmTables };

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** `action_failed` carries the owning plugin's own error code (`insufficient_funds`, `conflict`, …) in `actionCode`. */
+export declare class GmError extends GmError_base {
+}
+
+export declare const gmError: (code: GmError["code"], actionCode?: string) => GmError;
+
+declare const GmError_base: Schema.Class<GmError, Schema.TaggedStruct<"GmError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "forbidden", "not_found", "conflict", "unavailable", "action_failed"]>;
+    readonly actionCode: Schema.optional<Schema.String>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,18 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("GmError", {
+	code: e.Literals([
+		"identity_required",
+		"invalid_input",
+		"forbidden",
+		"not_found",
+		"conflict",
+		"unavailable",
+		"action_failed"
+	]),
+	actionCode: e.optional(e.String)
+}) {}, n = (e, n) => new t(n === void 0 ? { code: e } : {
+	code: e,
+	actionCode: n
+});
+export { t as GmError, n as gmError };