@discord-mcbe/client 0.0.1 → 4.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 tutinoko2048/RetoRuto9900K
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bds.d.ts

@@ -0,0 +1,16 @@
+import { n as ClientType, t as BaseClient } from "./index-CzbgOaig.js";
+import { ScriptBridgeClient } from "@script-bridge/client";
+
+//#region src/bds.d.ts
+interface BridgeClientOptions {
+  host?: string;
+  port?: number;
+  clientId?: string | (() => string);
+}
+declare class BridgeClient extends BaseClient<ScriptBridgeClient> {
+  readonly type = ClientType.BDS;
+  constructor(options?: BridgeClientOptions);
+  start(): Promise<void>;
+}
+//#endregion
+export { BridgeClient, BridgeClientOptions };

package/dist/bds.js

@@ -0,0 +1,33 @@
+import { n as ClientType, t as BaseClient } from "./client-DgUd3XAf.js";
+import { world } from "@minecraft/server";
+import { ScriptBridgeClient } from "@script-bridge/client";
+
+//#region src/bds.ts
+const defaultOptions = {
+	host: "localhost",
+	port: 23191,
+	clientId: () => world.getDynamicProperty("clientId") ?? "discord-mcbe-bds"
+};
+var BridgeClient = class extends BaseClient {
+	type = ClientType.BDS;
+	constructor(options = {}) {
+		const mergedOptions = {
+			...defaultOptions,
+			...options
+		};
+		const bridge = new ScriptBridgeClient({
+			url: `http://${mergedOptions.host}:${mergedOptions.port}`,
+			clientId: mergedOptions.clientId
+		});
+		super(bridge);
+	}
+	async start() {
+		console.log("[discord-mcbe] Connecting to discord-mcbe server...");
+		const requestedAt = Date.now();
+		await this.bridge.connect();
+		console.log(`[discord-mcbe] Connection established! (${Date.now() - requestedAt}ms)`);
+	}
+};
+
+//#endregion
+export { BridgeClient };

package/dist/client-DgUd3XAf.js

@@ -0,0 +1,360 @@
+import { CommandPermissionLevel, CustomCommandParamType, CustomCommandStatus, ObjectiveSortOrder, Player, ScoreboardIdentityType, system, world } from "@minecraft/server";
+import { ActionId } from "@discord-mcbe/shared";
+import { ModalFormData } from "@minecraft/server-ui";
+
+//#region src/client/descriptors.ts
+function createPlayerDescriptor(player) {
+	return {
+		name: player.name,
+		nameTag: player.nameTag,
+		uniqueId: player.id,
+		platformType: player.clientSystemInfo.platformType
+	};
+}
+function createDimensionDescriptor(dimension) {
+	return {
+		id: dimension.id,
+		heightRange: dimension.heightRange
+	};
+}
+function createScoreboardObjectiveDescriptor(objective) {
+	return {
+		id: objective.id,
+		displayName: objective.displayName
+	};
+}
+function createScoreboardIdentityDescriptor(identity) {
+	let entityUniqueId;
+	if ((identity.type === ScoreboardIdentityType.Entity || identity.type === ScoreboardIdentityType.Player) && identity.displayName !== "commands.scoreboard.players.offlinePlayerName") entityUniqueId = identity.getEntity()?.id;
+	return {
+		type: identity.type,
+		id: identity.id,
+		displayName: identity.displayName,
+		entityUniqueId
+	};
+}
+function createScoreboardScoreInfoDescriptor(info) {
+	return {
+		score: info.score,
+		participant: createScoreboardIdentityDescriptor(info.participant)
+	};
+}
+
+//#endregion
+//#region src/client/util.ts
+let lastTick;
+const deltaTimes = [];
+system.runInterval(() => {
+	const now = Date.now();
+	if (lastTick) {
+		if (deltaTimes.length > 60) deltaTimes.shift();
+		deltaTimes.push(now - lastTick);
+	}
+	lastTick = now;
+});
+function getTPS() {
+	if (deltaTimes.length === 0) return 20;
+	const tps = 1e3 / (deltaTimes.reduce((sum, delta) => sum + delta, 0) / deltaTimes.length);
+	return Math.floor(tps * 100) / 100;
+}
+
+//#endregion
+//#region src/client/handler.ts
+function registerHandlers(bridge) {
+	bridge.registerHandler(ActionId.SendMessage, (action) => {
+		const { message, playerUniqueId } = action.data;
+		if (playerUniqueId) {
+			const player = world.getEntity(playerUniqueId);
+			if (!(player instanceof Player)) throw new Error("Player not found");
+			player.sendMessage(message);
+		} else world.sendMessage(message);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.RunCommand, (action) => {
+		const { command } = action.data;
+		const { successCount } = world.getDimension("overworld").runCommand(command);
+		action.respond({ successCount });
+	});
+	bridge.registerHandler(ActionId.SendScriptEvent, (action) => {
+		const { id, message } = action.data;
+		system.sendScriptEvent(id, message);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.GetTPS, (action) => {
+		const tps = getTPS();
+		action.respond({ tps });
+	});
+	bridge.registerHandler(ActionId.GetEntityLocation, (action) => {
+		const { entityUniqueId } = action.data;
+		const entity = world.getEntity(entityUniqueId);
+		if (!entity) throw new Error("Entity not found");
+		action.respond({ location: entity.location });
+	});
+	bridge.registerHandler(ActionId.GetEntityDimension, (action) => {
+		const { entityUniqueId } = action.data;
+		const entity = world.getEntity(entityUniqueId);
+		if (!entity) throw new Error("Entity not found");
+		action.respond({ dimension: createDimensionDescriptor(entity.dimension) });
+	});
+	bridge.registerHandler(ActionId.GetGameMode, (action) => {
+		const { playerUniqueId } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		action.respond({ gameMode: player.getGameMode() });
+	});
+	bridge.registerHandler(ActionId.SetGameMode, (action) => {
+		const { playerUniqueId, gameMode } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		player.setGameMode(gameMode);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.SetTitle, (action) => {
+		const { playerUniqueId, title, options } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		player.onScreenDisplay.setTitle(title, options);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.UpdateSubtitle, (action) => {
+		const { playerUniqueId, subtitle } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		player.onScreenDisplay.updateSubtitle(subtitle);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.SetActionBar, (action) => {
+		const { playerUniqueId, text } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		player.onScreenDisplay.setActionBar(text);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.KickPlayer, (action) => {
+		const { playerUniqueId, reason } = action.data;
+		const player = world.getEntity(playerUniqueId);
+		if (!(player instanceof Player)) throw new Error("Player not found");
+		player.runCommand(`kick @s ${reason ? reason : ""}`);
+		action.respond();
+	});
+	bridge.registerHandler(ActionId.GetScore, (action) => {
+		const { objectiveId, participant } = action.data;
+		const objective = world.scoreboard.getObjective(objectiveId);
+		if (!objective) throw new Error(`Objective '${objectiveId}' not found`);
+		const target = participant.uniqueId ? world.getEntity(participant.uniqueId) : participant.fakePlayer;
+		if (!target) throw new Error(`Participant '${participant.uniqueId}' not found`);
+		action.respond({ value: target ? objective.getScore(target) ?? null : null });
+	});
+	bridge.registerHandler(ActionId.UpdateScore, (action) => {
+		const { objectiveId, participant, type, score } = action.data;
+		const objective = world.scoreboard.getObjective(objectiveId);
+		if (!objective) throw new Error(`Objective '${objectiveId}' not found`);
+		const target = participant.uniqueId ? world.getEntity(participant.uniqueId) : participant.fakePlayer;
+		if (!target) throw new Error(`Participant '${participant.uniqueId}' not found`);
+		let newScore = score;
+		if (type === "set") objective.setScore(target, score);
+		else if (type === "add") newScore = objective.addScore(target, score);
+		action.respond({ value: newScore });
+	});
+	bridge.registerHandler(ActionId.GetAllScores, (action) => {
+		const { objectiveId } = action.data;
+		const objective = world.scoreboard.getObjective(objectiveId);
+		if (!objective) throw new Error(`Objective '${objectiveId}' not found`);
+		const scores = objective.getScores().map(createScoreboardScoreInfoDescriptor);
+		action.respond({ scores });
+	});
+	bridge.registerHandler(ActionId.RemoveParticipant, (action) => {
+		const { objectiveId, participant } = action.data;
+		const objective = world.scoreboard.getObjective(objectiveId);
+		if (!objective) throw new Error(`Objective '${objectiveId}' not found`);
+		const target = participant.uniqueId ? world.getEntity(participant.uniqueId) : participant.fakePlayer;
+		if (!target) throw new Error(`Participant '${participant.uniqueId}' not found`);
+		action.respond({ result: objective.removeParticipant(target) });
+	});
+	bridge.registerHandler(ActionId.GetObjective, (action) => {
+		const { objectiveId } = action.data;
+		const objective = world.scoreboard.getObjective(objectiveId);
+		action.respond({ objective: objective ? createScoreboardObjectiveDescriptor(objective) : void 0 });
+	});
+	bridge.registerHandler(ActionId.GetAllObjectives, (action) => {
+		const objectiveDescriptors = world.scoreboard.getObjectives().map(createScoreboardObjectiveDescriptor);
+		action.respond({ objectives: objectiveDescriptors });
+	});
+	bridge.registerHandler(ActionId.UpdateObjective, (action) => {
+		const { type, objectiveId, displayName } = action.data;
+		let objective;
+		if (type === "add") objective = world.scoreboard.addObjective(objectiveId, displayName);
+		else if (type === "remove") world.scoreboard.removeObjective(objectiveId);
+		action.respond({ objective: objective ? createScoreboardObjectiveDescriptor(objective) : void 0 });
+	});
+	bridge.registerHandler(ActionId.SetObjectiveDisplay, (action) => {
+		const { displaySlotId, objectiveId, sortOrder } = action.data;
+		if (objectiveId) {
+			const objective = world.scoreboard.getObjective(objectiveId);
+			if (!objective) throw new Error(`Objective '${objectiveId}' not found`);
+			world.scoreboard.setObjectiveAtDisplaySlot(displaySlotId, {
+				objective,
+				sortOrder: sortOrder ? ObjectiveSortOrder[sortOrder] : void 0
+			});
+		} else world.scoreboard.clearObjectiveAtDisplaySlot(displaySlotId);
+		action.respond();
+	});
+}
+
+//#endregion
+//#region src/client/event.ts
+function registerEvents(bridge) {
+	world.afterEvents.playerSpawn.subscribe((ev) => {
+		if (!bridge.isConnected || !ev.initialSpawn) return;
+		bridge.send(ActionId.PlayerJoin, { player: createPlayerDescriptor(ev.player) });
+	});
+	world.afterEvents.playerLeave.subscribe((ev) => {
+		if (!bridge.isConnected) return;
+		bridge.send(ActionId.PlayerLeave, { playerUniqueId: ev.playerId });
+	});
+	world.afterEvents.chatSend.subscribe((ev) => {
+		if (!bridge.isConnected) return;
+		bridge.send(ActionId.ChatSend, {
+			senderName: ev.sender.name,
+			senderUniqueId: ev.sender.id,
+			message: ev.message
+		});
+	});
+}
+
+//#endregion
+//#region src/client/features/settings.ts
+var SettingsForm = class SettingsForm {
+	constructor(player, client) {
+		this.player = player;
+		this.client = client;
+	}
+	static async show(player, client) {
+		await new SettingsForm(player, client).main();
+	}
+	async main() {
+		const res = await new ModalFormData().title("discord-mcbe settings").textField("clientId", "Client ID", { defaultValue: this.client.getClientId() }).show(this.player);
+		if (res.canceled || !res.formValues) return;
+		const newClientId = res.formValues[0];
+		this.client.setClientId(newClientId);
+	}
+};
+
+//#endregion
+//#region src/client/command.ts
+function registerCommands(registry, client) {
+	for (const commandName of ["dmc:dmc", "dmc:discord-mcbe"]) registry.registerCommand({
+		name: commandName,
+		description: "Open discord-mcbe settings",
+		permissionLevel: CommandPermissionLevel.Admin
+	}, (origin) => {
+		const player = origin.sourceEntity;
+		if (!(player instanceof Player)) return {
+			status: CustomCommandStatus.Failure,
+			message: "This command can only be used by players."
+		};
+		system.run(() => SettingsForm.show(player, client));
+		return { status: CustomCommandStatus.Success };
+	});
+	registry.registerCommand({
+		name: "dmc:setid",
+		description: "Set the clientId for discord-mcbe (requires reconnect)",
+		permissionLevel: CommandPermissionLevel.Host,
+		mandatoryParameters: [{
+			type: CustomCommandParamType.String,
+			name: "clientId"
+		}]
+	}, (_, clientId) => {
+		client.setClientId(clientId);
+		return {
+			status: CustomCommandStatus.Success,
+			message: `Updated clientId to "${clientId}".`
+		};
+	});
+	registry.registerCommand({
+		name: "dmc:disconnect",
+		description: "Disconnect from discord-mcbe server",
+		permissionLevel: CommandPermissionLevel.Admin
+	}, () => {
+		if (client.bridge.isConnected) {
+			client.bridge.disconnect();
+			return {
+				status: CustomCommandStatus.Success,
+				message: "Disconnecting from discord-mcbe server..."
+			};
+		} else return {
+			status: CustomCommandStatus.Failure,
+			message: "discord-mcbe is not connected now."
+		};
+	});
+}
+
+//#endregion
+//#region src/utils/logger.ts
+var Logger = class {
+	constructor(name) {
+		this.name = name;
+	}
+	log(...message) {
+		console.log(`[${this.name}] ${this.formatMessage(message)}`);
+	}
+	info(...message) {
+		console.info(`[${this.name}] ${this.formatMessage(message)}`);
+	}
+	warn(...message) {
+		console.warn(`[${this.name}] ${this.formatMessage(message)}`);
+	}
+	error(...message) {
+		console.error(`[${this.name}] ${this.formatMessage(message)}`);
+	}
+	debug(...message) {}
+	formatMessage(message) {
+		return message.map((msg) => {
+			if (msg instanceof Error) return msg.stack ?? msg;
+			else if (typeof msg !== "string") return JSON.stringify(msg, null, 2);
+			return msg;
+		}).join(" ");
+	}
+};
+
+//#endregion
+//#region src/client/base-client.ts
+let ClientType = /* @__PURE__ */ function(ClientType$1) {
+	ClientType$1["Local"] = "Local";
+	ClientType$1["BDS"] = "BDS";
+	return ClientType$1;
+}({});
+var BaseClient = class {
+	bridge;
+	logger = new Logger("discord-mcbe");
+	constructor(bridge) {
+		this.bridge = bridge;
+		registerHandlers(this.bridge);
+		registerEvents(this.bridge);
+		system.beforeEvents.startup.subscribe((ev) => registerCommands(ev.customCommandRegistry, this));
+		this.bridge.on("connect", this.onConnect.bind(this));
+	}
+	setClientId(clientId) {
+		world.setDynamicProperty("clientId", clientId);
+	}
+	getClientId() {
+		return world.getDynamicProperty("clientId");
+	}
+	async onConnect() {
+		const players = world.getPlayers();
+		try {
+			await this.bridge.send(ActionId.WorldInitialize, { players: players.map(createPlayerDescriptor) });
+		} catch (error) {
+			this.logger.error("Failed to send WorldInitializeAction:", error);
+		}
+	}
+	isLocal() {
+		return this.type === ClientType.Local;
+	}
+	isBDS() {
+		return this.type === ClientType.BDS;
+	}
+};
+
+//#endregion
+export { ClientType as n, Logger as r, BaseClient as t };

package/dist/index-CzbgOaig.d.ts

@@ -0,0 +1,112 @@
+import { ActionId } from "@discord-mcbe/shared";
+import { ActionHandler, ScriptBridgeClient } from "@script-bridge/client";
+import { BaseAction, DisconnectReason } from "@script-bridge/protocol";
+
+//#region src/utils/emitter.d.ts
+type Listener$1<T> = (data: T) => void;
+declare class Emitter<T> {
+  private listeners;
+  on<K extends keyof T>(event: K, listener: Listener$1<T[K]>): void;
+  once<K extends keyof T>(event: K, listener: Listener$1<T[K]>): void;
+  emit<K extends keyof T>(event: K, data: T[K]): void;
+  off<K extends keyof T>(event: K, listener: Listener$1<T[K]>): void;
+  removeAllListeners<K extends keyof T>(event: K): void;
+}
+//#endregion
+//#region src/utils/logger.d.ts
+declare class Logger {
+  private readonly name;
+  constructor(name: string);
+  log(...message: unknown[]): void;
+  info(...message: unknown[]): void;
+  warn(...message: unknown[]): void;
+  error(...message: unknown[]): void;
+  debug(...message: unknown[]): void;
+  private formatMessage;
+}
+//#endregion
+//#region src/transport/interfaces.d.ts
+type Listener<T> = (data: T) => void;
+type IResponse<T = unknown> = {
+  error?: false;
+  data: T;
+} | {
+  error: true;
+  message: string;
+};
+interface IBridgeClient {
+  isConnected: boolean;
+  send<T extends BaseAction = BaseAction>(channelId: ActionId, data?: T['request']): Promise<IResponse<T['response']>>;
+  registerHandler<A extends BaseAction = BaseAction>(channelId: A['id'], handler: ActionHandler<A>): void;
+  disconnect(reason?: DisconnectReason): Promise<void>;
+  on(event: 'connect', listener: Listener<{
+    sessionId: string;
+  }>): void;
+  on(event: 'disconnect', listener: Listener<{
+    reason: DisconnectReason;
+  }>): void;
+}
+//#endregion
+//#region src/transport/socket.d.ts
+interface SocketEvents {
+  ready: {};
+  connect: {
+    sessionId: string;
+  };
+  disconnect: {
+    reason: DisconnectReason;
+  };
+}
+interface ClientOptions {
+  clientId: string | (() => string);
+}
+declare class SocketBridgeClient extends Emitter<SocketEvents> implements IBridgeClient {
+  static readonly PROTOCOL_VERSION = 1;
+  private readonly _clientId;
+  private readonly sendQueue;
+  private readonly awaitingResponses;
+  private readonly actionHandlers;
+  private readonly deltaTimes;
+  private readonly logger;
+  private previousRequestId;
+  private currentSessionId;
+  private lastQueryReceivedAt;
+  constructor(options: ClientOptions);
+  get isConnected(): boolean;
+  get clientId(): string;
+  send<A extends BaseAction = BaseAction>(channelId: A['id'], data?: A['request']): Promise<IResponse<A['response']>>;
+  registerHandler<A extends BaseAction = BaseAction>(channelId: A['id'], handler: ActionHandler<A>): void;
+  disconnect(reason?: DisconnectReason): Promise<void>;
+  destroy(): void;
+  private clearResponses;
+  private handleConnection;
+  private handleResponse;
+  private handleRequest;
+  private getQueue;
+  private onQuery;
+  /** Process incoming messages from server */
+  private onMessage;
+  /**
+   * Register internal commands
+   */
+  private onStartup;
+}
+//#endregion
+//#region src/client/base-client.d.ts
+declare enum ClientType {
+  Local = "Local",
+  BDS = "BDS",
+}
+declare abstract class BaseClient<T extends IBridgeClient = IBridgeClient> {
+  readonly bridge: T;
+  readonly logger: Logger;
+  abstract readonly type: ClientType;
+  constructor(bridge: T);
+  setClientId(clientId: string): void;
+  getClientId(): string | undefined;
+  private onConnect;
+  isLocal(): this is BaseClient<SocketBridgeClient>;
+  isBDS(): this is BaseClient<ScriptBridgeClient>;
+}
+//#endregion
+export { ClientType as n, SocketBridgeClient as r, BaseClient as t };

package/dist/local.d.ts

@@ -0,0 +1,12 @@
+import { n as ClientType, r as SocketBridgeClient, t as BaseClient } from "./index-CzbgOaig.js";
+
+//#region src/local.d.ts
+interface BridgeClientOptions {
+  clientId?: string | (() => string);
+}
+declare class BridgeClient extends BaseClient<SocketBridgeClient> {
+  readonly type = ClientType.Local;
+  constructor(options?: BridgeClientOptions);
+}
+//#endregion
+export { BridgeClient, BridgeClientOptions };

package/dist/local.js

@@ -0,0 +1,277 @@
+import { n as ClientType, r as Logger, t as BaseClient } from "./client-DgUd3XAf.js";
+import { CommandPermissionLevel, CustomCommandParamType, CustomCommandStatus, system, world } from "@minecraft/server";
+import { SocketBridge } from "@discord-mcbe/shared";
+import { DisconnectReason, InternalAction, PayloadType, ResponseErrorReason } from "@script-bridge/protocol";
+
+//#region src/utils/emitter.ts
+var Emitter = class {
+	listeners = /* @__PURE__ */ new Map();
+	on(event, listener) {
+		let listeners = this.listeners.get(event);
+		if (!listeners) {
+			listeners = [];
+			this.listeners.set(event, listeners);
+		}
+		listeners.push(listener);
+	}
+	once(event, listener) {
+		const onceListener = (data) => {
+			listener(data);
+			this.off(event, onceListener);
+		};
+		this.on(event, onceListener);
+	}
+	emit(event, data) {
+		for (const listener of this.listeners.get(event) ?? []) listener(data);
+	}
+	off(event, listener) {
+		const currentListeners = this.listeners.get(event);
+		if (currentListeners) this.listeners.set(event, currentListeners.filter((l) => l !== listener));
+	}
+	removeAllListeners(event) {
+		this.listeners.set(event, []);
+	}
+};
+
+//#endregion
+//#region src/transport/socket.ts
+var SocketBridgeClient = class SocketBridgeClient extends Emitter {
+	static PROTOCOL_VERSION = SocketBridge.PROTOCOL_VERSION;
+	_clientId;
+	sendQueue = [];
+	awaitingResponses = /* @__PURE__ */ new Map();
+	actionHandlers = /* @__PURE__ */ new Map();
+	deltaTimes = [];
+	logger = new Logger("discord-mcbe");
+	previousRequestId = 0;
+	currentSessionId = null;
+	lastQueryReceivedAt = null;
+	constructor(options) {
+		super();
+		this._clientId = options.clientId;
+		system.beforeEvents.startup.subscribe(this.onStartup.bind(this));
+		system.afterEvents.scriptEventReceive.subscribe((event) => {
+			if (event.id === "bridge:message") this.onMessage(event.message.trim());
+		}, { namespaces: ["bridge"] });
+		world.afterEvents.worldLoad.subscribe(() => {
+			this.emit("ready", {});
+		});
+	}
+	get isConnected() {
+		return this.currentSessionId !== null;
+	}
+	get clientId() {
+		return typeof this._clientId === "function" ? this._clientId() : this._clientId;
+	}
+	async send(channelId, data) {
+		if (!this.currentSessionId) throw new Error("No active session");
+		const requestId = ++this.previousRequestId;
+		this.sendQueue.push({
+			type: PayloadType.Request,
+			channelId,
+			data,
+			sessionId: this.currentSessionId,
+			requestId
+		});
+		return new Promise((resolve) => {
+			this.awaitingResponses.set(requestId, (response) => {
+				resolve(response);
+			});
+		});
+	}
+	registerHandler(channelId, handler) {
+		if (this.actionHandlers.has(channelId)) console.warn("[SocketBridge] Overwriting existing handler for channel:", channelId);
+		this.actionHandlers.set(channelId, handler);
+	}
+	async disconnect(reason = DisconnectReason.Disconnect) {
+		try {
+			await this.send(InternalAction.Disconnect, { reason });
+		} catch (e) {
+			this.logger.warn("Failed to send disconnect message", e);
+		}
+		this.destroy();
+		this.emit("disconnect", { reason });
+	}
+	destroy() {
+		this.clearResponses();
+		this.sendQueue.length = 0;
+		this.deltaTimes.length = 0;
+		this.lastQueryReceivedAt = null;
+		this.currentSessionId = null;
+	}
+	clearResponses() {
+		for (const [requestId, resolve] of this.awaitingResponses.entries()) resolve({
+			type: PayloadType.Response,
+			error: true,
+			message: "Session disconnected before response was received",
+			errorReason: ResponseErrorReason.Abort,
+			sessionId: this.currentSessionId,
+			requestId
+		});
+		this.awaitingResponses.clear();
+	}
+	handleConnection(protocolVersion, sessionId) {
+		let body;
+		if (SocketBridgeClient.PROTOCOL_VERSION > protocolVersion) body = {
+			error: true,
+			errorReason: DisconnectReason.OutdatedServer
+		};
+		else if (SocketBridgeClient.PROTOCOL_VERSION < protocolVersion) body = {
+			error: true,
+			errorReason: DisconnectReason.OutdatedClient
+		};
+		else {
+			body = {
+				protocolVersion: SocketBridgeClient.PROTOCOL_VERSION,
+				clientId: this.clientId
+			};
+			this.destroy();
+			this.currentSessionId = sessionId;
+			this.emit("connect", { sessionId });
+		}
+		return {
+			status: CustomCommandStatus.Success,
+			message: JSON.stringify(body)
+		};
+	}
+	async handleResponse(response) {
+		const { requestId } = response;
+		const resolve = this.awaitingResponses.get(requestId);
+		if (resolve) {
+			resolve(response);
+			this.awaitingResponses.delete(requestId);
+		}
+	}
+	async handleRequest(request) {
+		const { requestId, sessionId, channelId } = request;
+		const handler = this.actionHandlers.get(channelId);
+		if (!handler) {
+			console.error("[SocketBridge] No handler for channel:", channelId);
+			this.sendQueue.push({
+				type: PayloadType.Response,
+				error: true,
+				errorReason: ResponseErrorReason.UnhandledRequest,
+				message: `No handler found for channel: ${channelId}`,
+				requestId,
+				sessionId
+			});
+			return;
+		}
+		try {
+			await handler({
+				data: request.data,
+				respond: (data) => {
+					this.sendQueue.push({
+						type: PayloadType.Response,
+						data,
+						requestId,
+						sessionId
+					});
+				}
+			});
+		} catch (err) {
+			console.error("[SocketBridge] Error while handling request:", channelId, err);
+			this.sendQueue.push({
+				type: PayloadType.Response,
+				error: true,
+				errorReason: ResponseErrorReason.InternalError,
+				message: `An error occurred while handling the request\n${String(err)}`,
+				requestId,
+				sessionId
+			});
+		}
+	}
+	getQueue() {
+		const queue = this.sendQueue.slice();
+		this.sendQueue.length = 0;
+		return queue;
+	}
+	onQuery(sessionId) {
+		let result;
+		if (this.currentSessionId === sessionId) {
+			result = {
+				error: false,
+				data: this.getQueue()
+			};
+			const now = Date.now();
+			if (this.lastQueryReceivedAt !== null) {
+				this.deltaTimes.push(now - this.lastQueryReceivedAt);
+				if (this.deltaTimes.length > 20) this.deltaTimes.shift();
+			}
+			this.lastQueryReceivedAt = now;
+		} else result = {
+			error: true,
+			errorReason: ResponseErrorReason.InvalidSession
+		};
+		return {
+			status: CustomCommandStatus.Success,
+			message: JSON.stringify(result)
+		};
+	}
+	/** Process incoming messages from server */
+	onMessage(rawMessage) {
+		let message;
+		try {
+			message = JSON.parse(rawMessage);
+		} catch (e) {
+			console.error("[SocketBridge] Failed to parse message from bridge:", e);
+			return;
+		}
+		if (message.type === PayloadType.Response) this.handleResponse(message).catch((error) => {
+			console.error("[SocketBridge] Failed to handle response:", error);
+		});
+		else if (message.type === PayloadType.Request) this.handleRequest(message).catch((error) => {
+			console.error("[SocketBridge] Failed to handle request:", error);
+		});
+	}
+	/**
+	* Register internal commands
+	*/
+	onStartup(ev) {
+		const registry = ev.customCommandRegistry;
+		registry.registerCommand({
+			name: "dmc:__query__",
+			description: "§8[internal] query messages for SocketBridge",
+			permissionLevel: CommandPermissionLevel.Host,
+			mandatoryParameters: [{
+				name: "sessionId",
+				type: CustomCommandParamType.String
+			}]
+		}, (_, sessionId) => this.onQuery(sessionId));
+		registry.registerCommand({
+			name: "dmc:__connect__",
+			description: "§8[internal] initialize connection for SocketBridge",
+			permissionLevel: CommandPermissionLevel.Host,
+			mandatoryParameters: [{
+				name: "protocolVersion",
+				type: CustomCommandParamType.Integer
+			}, {
+				name: "sessionId",
+				type: CustomCommandParamType.String
+			}]
+		}, (_, protocolVersion, sessionId) => this.handleConnection(protocolVersion, sessionId));
+	}
+};
+
+//#endregion
+//#region src/local.ts
+const defaultOptions = { clientId: () => world.getDynamicProperty("clientId") ?? "discord-mcbe-local" };
+var BridgeClient = class extends BaseClient {
+	type = ClientType.Local;
+	constructor(options = {}) {
+		const bridge = new SocketBridgeClient({
+			...defaultOptions,
+			...options
+		});
+		super(bridge);
+		bridge.on("ready", () => {
+			console.info("[discord-mcbe] Listening connection from discord-mcbe server...");
+		});
+		bridge.on("connect", () => {
+			console.info("[discord-mcbe] Connection established!");
+		});
+	}
+};
+
+//#endregion
+export { BridgeClient };

package/package.json

@@ -1,10 +1,43 @@
 {
   "name": "@discord-mcbe/client",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @discord-mcbe/client",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "4.0.0-beta.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tutinoko2048/discord-mcbe.git",
+    "directory": "packages/client"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./bds": {
+      "default": "./dist/bds.js",
+      "types": "./dist/bds.d.ts"
+    },
+    "./local": {
+      "default": "./dist/local.js",
+      "types": "./dist/local.d.ts"
+    }
+  },
+  "dependencies": {
+    "@minecraft/server": "2.5.0-beta.1.21.130-stable",
+    "@minecraft/server-ui": "2.0.0",
+    "@script-bridge/client": "^0.5.0",
+    "@script-bridge/protocol": "^0.5.0",
+    "@discord-mcbe/shared": "4.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@bedrock-apis/env-types": "1.0.0-beta.6",
+    "@discord-mcbe/internal-config": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "lint": "vp lint",
+    "lint:fix": "vp lint --fix",
+    "format": "vp fmt",
+    "check": "vp check",
+    "clean": "rimraf dist .turbo tsconfig.tsbuildinfo"
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# @discord-mcbe/client
-
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@discord-mcbe/client`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**