@ho3einwave/pterodactyl-ts 0.1.0

package/dist/index.mjs

@@ -0,0 +1,911 @@
+//#region src/core/errors.ts
+/** Base error for all Pterodactyl API errors. */
+var PteroError = class extends Error {
+	/** HTTP status code. */
+	status;
+	/** Machine-readable error code from the API. */
+	code;
+	/** Raw error objects from the API response. */
+	errors;
+	constructor(status, errors) {
+		const first = errors[0];
+		super(first?.detail ?? `API error ${status}`);
+		this.name = "PteroError";
+		this.status = status;
+		this.code = first?.code ?? "UnknownError";
+		this.errors = errors;
+	}
+};
+/** Thrown on 422 validation errors. Includes per-field error details. */
+var PteroValidationError = class extends PteroError {
+	/** Map of field name to error messages. */
+	fieldErrors;
+	constructor(errors) {
+		super(422, errors);
+		this.name = "PteroValidationError";
+		this.fieldErrors = {};
+		for (const err of errors) if (err.source?.field) {
+			const field = err.source.field;
+			if (!this.fieldErrors[field]) this.fieldErrors[field] = [];
+			this.fieldErrors[field].push(err.detail);
+		}
+	}
+};
+/** Thrown on 429 rate limit errors. Includes retry timing info. */
+var PteroRateLimitError = class extends PteroError {
+	/** Seconds to wait before retrying (from Retry-After header). */
+	retryAfter;
+	constructor(errors, retryAfter) {
+		super(429, errors);
+		this.name = "PteroRateLimitError";
+		this.retryAfter = retryAfter;
+	}
+};
+
+//#endregion
+//#region src/core/http-client.ts
+var HttpClient = class {
+	baseUrl;
+	apiKey;
+	_rateLimit = null;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+		this.apiKey = options.apiKey;
+	}
+	/** Current rate limit info from the last response, or null if no request has been made. */
+	get rateLimit() {
+		return this._rateLimit;
+	}
+	/** Make a GET request and unwrap a single object envelope. */
+	async get(path, options) {
+		return (await (await this.request("GET", path, void 0, options)).json()).attributes;
+	}
+	/** Make a GET request and unwrap a list envelope with pagination. */
+	async getList(path, options) {
+		const json = await (await this.request("GET", path, void 0, options)).json();
+		return this.unwrapList(json);
+	}
+	/** Make a POST request and unwrap a single object envelope. */
+	async post(path, body, options) {
+		const response = await this.request("POST", path, body, options);
+		if (response.status === 204) return;
+		return (await response.json()).attributes;
+	}
+	/** Make a PUT request and unwrap a single object envelope. */
+	async put(path, body, options) {
+		const response = await this.request("PUT", path, body, options);
+		if (response.status === 204) return;
+		return (await response.json()).attributes;
+	}
+	/** Make a PATCH request and unwrap a single object envelope. */
+	async patch(path, body, options) {
+		const response = await this.request("PATCH", path, body, options);
+		if (response.status === 204) return;
+		return (await response.json()).attributes;
+	}
+	/** Make a DELETE request. Returns void (expects 204). */
+	async delete(path, body, options) {
+		await this.request("DELETE", path, body, options);
+	}
+	/** Make a raw request and return the Response (for non-JSON endpoints like file downloads). */
+	async raw(method, path, body, options) {
+		return this.request(method, path, body, options);
+	}
+	/** Make a request with a raw text body (Content-Type: text/plain). */
+	async postText(path, text, options) {
+		const url = this.buildUrl(path, options);
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${this.apiKey}`,
+				Accept: "Application/vnd.pterodactyl.v1+json",
+				"Content-Type": "text/plain"
+			},
+			body: text
+		});
+		this.trackRateLimit(response);
+		if (!response.ok) await this.handleError(response);
+	}
+	async request(method, path, body, options) {
+		const url = this.buildUrl(path, options);
+		const headers = {
+			Authorization: `Bearer ${this.apiKey}`,
+			Accept: "Application/vnd.pterodactyl.v1+json"
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (body !== void 0) {
+			headers["Content-Type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const response = await fetch(url, init);
+		this.trackRateLimit(response);
+		if (!response.ok) await this.handleError(response);
+		return response;
+	}
+	buildUrl(path, options) {
+		const url = new URL(`${this.baseUrl}${path}`);
+		if (!options) return url.toString();
+		if (options.filters) for (const [key, value] of Object.entries(options.filters)) url.searchParams.set(`filter[${key}]`, value);
+		if (options.sort) url.searchParams.set("sort", options.sort);
+		if (options.include?.length) url.searchParams.set("include", options.include.join(","));
+		if (options.page !== void 0) url.searchParams.set("page", String(options.page));
+		if (options.perPage !== void 0) url.searchParams.set("per_page", String(options.perPage));
+		return url.toString();
+	}
+	trackRateLimit(response) {
+		const limit = response.headers.get("X-RateLimit-Limit");
+		const remaining = response.headers.get("X-RateLimit-Remaining");
+		const reset = response.headers.get("X-RateLimit-Reset");
+		if (limit && remaining && reset) this._rateLimit = {
+			limit: Number(limit),
+			remaining: Number(remaining),
+			reset: Number(reset)
+		};
+	}
+	async handleError(response) {
+		let errors;
+		try {
+			errors = (await response.json()).errors;
+		} catch {
+			errors = [{
+				code: "UnknownError",
+				status: String(response.status),
+				detail: response.statusText || `HTTP ${response.status}`
+			}];
+		}
+		if (response.status === 422) throw new PteroValidationError(errors);
+		if (response.status === 429) {
+			const retryAfter = Number(response.headers.get("Retry-After") ?? "60");
+			throw new PteroRateLimitError(errors, retryAfter);
+		}
+		throw new PteroError(response.status, errors);
+	}
+	unwrapList(raw) {
+		const data = raw.data.map((item) => item.attributes);
+		return {
+			data,
+			pagination: raw.meta?.pagination ? {
+				total: raw.meta.pagination.total,
+				count: raw.meta.pagination.count,
+				perPage: raw.meta.pagination.per_page,
+				currentPage: raw.meta.pagination.current_page,
+				totalPages: raw.meta.pagination.total_pages
+			} : {
+				total: data.length,
+				count: data.length,
+				perPage: data.length,
+				currentPage: 1,
+				totalPages: 1
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/client/account-manager.ts
+const BASE$6 = "/api/client/account";
+var AccountManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async getDetails() {
+		return this.http.get(BASE$6);
+	}
+	async get2FASetup() {
+		return (await (await this.http.raw("GET", `${BASE$6}/two-factor`)).json()).data;
+	}
+	async enable2FA(code) {
+		return this.http.post(`${BASE$6}/two-factor`, { code });
+	}
+	async disable2FA(password) {
+		await this.http.post(`${BASE$6}/two-factor/disable`, { password });
+	}
+	async updateEmail(email, password) {
+		await this.http.put(`${BASE$6}/email`, {
+			email,
+			password
+		});
+	}
+	async updatePassword(currentPassword, password, passwordConfirmation) {
+		await this.http.put(`${BASE$6}/password`, {
+			current_password: currentPassword,
+			password,
+			password_confirmation: passwordConfirmation
+		});
+	}
+	async listApiKeys() {
+		return (await this.http.getList(`${BASE$6}/api-keys`)).data;
+	}
+	async createApiKey(description, allowedIps) {
+		const json = await (await this.http.raw("POST", `${BASE$6}/api-keys`, {
+			description,
+			allowed_ips: allowedIps ?? []
+		})).json();
+		return {
+			...json.attributes,
+			secret_token: json.meta.secret_token
+		};
+	}
+	async deleteApiKey(identifier) {
+		await this.http.delete(`${BASE$6}/api-keys/${identifier}`);
+	}
+	async listSSHKeys() {
+		return (await this.http.getList(`${BASE$6}/ssh-keys`)).data;
+	}
+	async createSSHKey(name, publicKey) {
+		return this.http.post(`${BASE$6}/ssh-keys`, {
+			name,
+			public_key: publicKey
+		});
+	}
+	async deleteSSHKey(fingerprint) {
+		await this.http.post(`${BASE$6}/ssh-keys/remove`, { fingerprint });
+	}
+	async getActivity(options) {
+		return this.http.getList(`${BASE$6}/activity`, options);
+	}
+};
+
+//#endregion
+//#region src/client/server/backup-manager.ts
+var BackupManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/backups`;
+	}
+	async list(options) {
+		return this.http.getList(this.base, options);
+	}
+	async get(backupId) {
+		return this.http.get(`${this.base}/${backupId}`);
+	}
+	async create(params) {
+		return this.http.post(this.base, params);
+	}
+	async getDownloadUrl(backupId) {
+		return (await this.http.get(`${this.base}/${backupId}/download`)).url;
+	}
+	async delete(backupId) {
+		await this.http.delete(`${this.base}/${backupId}`);
+	}
+	async restore(backupId) {
+		await this.http.post(`${this.base}/${backupId}/restore`);
+	}
+	async toggleLock(backupId) {
+		await this.http.post(`${this.base}/${backupId}/lock`);
+	}
+};
+
+//#endregion
+//#region src/client/server/database-manager.ts
+var DatabaseManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/databases`;
+	}
+	async list() {
+		return (await this.http.getList(this.base)).data;
+	}
+	async create(params) {
+		return this.http.post(this.base, params);
+	}
+	async rotatePassword(databaseId) {
+		return this.http.post(`${this.base}/${databaseId}/rotate-password`);
+	}
+	async delete(databaseId) {
+		await this.http.delete(`${this.base}/${databaseId}`);
+	}
+};
+
+//#endregion
+//#region src/client/server/file-manager.ts
+var FileManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/files`;
+	}
+	async list(directory = "/") {
+		return (await this.http.getList(`${this.base}/list`, { filters: { directory } })).data;
+	}
+	async getContent(file) {
+		const path = `${this.base}/contents?file=${encodeURIComponent(file)}`;
+		return (await this.http.raw("GET", path)).text();
+	}
+	async writeFile(file, content) {
+		const path = `${this.base}/write?file=${encodeURIComponent(file)}`;
+		await this.http.postText(path, content);
+	}
+	async getUploadUrl(directory = "/") {
+		const path = `${this.base}/upload?directory=${encodeURIComponent(directory)}`;
+		return (await this.http.get(path)).url;
+	}
+	async getDownloadUrl(file) {
+		const path = `${this.base}/download?file=${encodeURIComponent(file)}`;
+		return (await this.http.get(path)).url;
+	}
+	async createFolder(root, name) {
+		await this.http.post(`${this.base}/create-folder`, {
+			root,
+			name
+		});
+	}
+	async copy(location) {
+		await this.http.post(`${this.base}/copy`, { location });
+	}
+	async rename(root, files) {
+		await this.http.put(`${this.base}/rename`, {
+			root,
+			files
+		});
+	}
+	async delete(root, files) {
+		await this.http.post(`${this.base}/delete`, {
+			root,
+			files
+		});
+	}
+	async compress(root, files) {
+		return this.http.post(`${this.base}/compress`, {
+			root,
+			files
+		});
+	}
+	async decompress(root, file) {
+		await this.http.post(`${this.base}/decompress`, {
+			root,
+			file
+		});
+	}
+	async chmod(root, files) {
+		await this.http.post(`${this.base}/chmod`, {
+			root,
+			files
+		});
+	}
+	async pull(url, directory, filename) {
+		await this.http.post(`${this.base}/pull`, {
+			url,
+			directory,
+			...filename && { filename }
+		});
+	}
+};
+
+//#endregion
+//#region src/client/server/network-manager.ts
+var NetworkManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/network/allocations`;
+	}
+	async list() {
+		return (await this.http.getList(this.base)).data;
+	}
+	async assign() {
+		return this.http.post(this.base);
+	}
+	async setPrimary(allocationId) {
+		return this.http.post(`${this.base}/${allocationId}/primary`);
+	}
+	async updateNotes(allocationId, notes) {
+		return this.http.post(`${this.base}/${allocationId}`, { notes });
+	}
+	async remove(allocationId) {
+		await this.http.delete(`${this.base}/${allocationId}`);
+	}
+};
+
+//#endregion
+//#region src/client/server/schedule-manager.ts
+var ScheduleManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/schedules`;
+	}
+	async list() {
+		return (await this.http.getList(this.base)).data;
+	}
+	async get(scheduleId) {
+		return this.http.get(`${this.base}/${scheduleId}`);
+	}
+	async create(params) {
+		return this.http.post(this.base, params);
+	}
+	async update(scheduleId, params) {
+		await this.http.post(`${this.base}/${scheduleId}`, params);
+	}
+	async delete(scheduleId) {
+		await this.http.delete(`${this.base}/${scheduleId}`);
+	}
+	async execute(scheduleId) {
+		await this.http.post(`${this.base}/${scheduleId}/execute`);
+	}
+	async createTask(scheduleId, params) {
+		return this.http.post(`${this.base}/${scheduleId}/tasks`, params);
+	}
+	async updateTask(scheduleId, taskId, params) {
+		return this.http.post(`${this.base}/${scheduleId}/tasks/${taskId}`, params);
+	}
+	async deleteTask(scheduleId, taskId) {
+		await this.http.delete(`${this.base}/${scheduleId}/tasks/${taskId}`);
+	}
+};
+
+//#endregion
+//#region src/client/server/subuser-manager.ts
+var SubuserManager = class {
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}/users`;
+	}
+	async list() {
+		return (await this.http.getList(this.base)).data;
+	}
+	async get(userId) {
+		return this.http.get(`${this.base}/${userId}`);
+	}
+	async create(params) {
+		return this.http.post(this.base, params);
+	}
+	async update(userId, params) {
+		return this.http.post(`${this.base}/${userId}`, params);
+	}
+	async remove(userId) {
+		await this.http.delete(`${this.base}/${userId}`);
+	}
+};
+
+//#endregion
+//#region src/client/server/server-context.ts
+var ServerContext = class {
+	files;
+	databases;
+	backups;
+	schedules;
+	network;
+	subusers;
+	base;
+	constructor(http, serverId) {
+		this.http = http;
+		this.base = `/api/client/servers/${serverId}`;
+		this.files = new FileManager(http, serverId);
+		this.databases = new DatabaseManager(http, serverId);
+		this.backups = new BackupManager(http, serverId);
+		this.schedules = new ScheduleManager(http, serverId);
+		this.network = new NetworkManager(http, serverId);
+		this.subusers = new SubuserManager(http, serverId);
+	}
+	async getDetails(options) {
+		return this.http.get(this.base, options);
+	}
+	async getResources() {
+		return this.http.get(`${this.base}/resources`);
+	}
+	async sendCommand(command) {
+		await this.http.post(`${this.base}/command`, { command });
+	}
+	async setPowerState(signal) {
+		await this.http.post(`${this.base}/power`, { signal });
+	}
+	async getWebSocketCredentials() {
+		return this.http.get(`${this.base}/websocket`);
+	}
+	async listStartupVariables() {
+		return (await this.http.getList(`${this.base}/startup`)).data;
+	}
+	async updateStartupVariable(key, value) {
+		return this.http.put(`${this.base}/startup/variable`, {
+			key,
+			value
+		});
+	}
+	async rename(name) {
+		await this.http.post(`${this.base}/settings/rename`, { name });
+	}
+	async reinstall() {
+		await this.http.post(`${this.base}/settings/reinstall`);
+	}
+};
+
+//#endregion
+//#region src/client/servers-manager.ts
+const BASE$5 = "/api/client";
+var ServersManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(`${BASE$5}`, options);
+	}
+};
+
+//#endregion
+//#region src/client/index.ts
+var PteroClient = class {
+	account;
+	servers;
+	http;
+	constructor(options) {
+		this.http = new HttpClient(options);
+		this.account = new AccountManager(this.http);
+		this.servers = new ServersManager(this.http);
+	}
+	/** Create a server context scoped to a specific server identifier. */
+	server(serverId) {
+		return new ServerContext(this.http, serverId);
+	}
+	/** Current rate limit info from the last API response. */
+	get rateLimit() {
+		return this.http.rateLimit;
+	}
+};
+
+//#endregion
+//#region src/application/location-manager.ts
+const BASE$4 = "/api/application/locations";
+var LocationManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(BASE$4, options);
+	}
+	async get(locationId, options) {
+		return this.http.get(`${BASE$4}/${locationId}`, options);
+	}
+	async create(params) {
+		return this.http.post(BASE$4, params);
+	}
+	async update(locationId, params) {
+		return this.http.patch(`${BASE$4}/${locationId}`, params);
+	}
+	async delete(locationId) {
+		await this.http.delete(`${BASE$4}/${locationId}`);
+	}
+};
+
+//#endregion
+//#region src/application/nest-manager.ts
+const BASE$3 = "/api/application/nests";
+var NestManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(BASE$3, options);
+	}
+	async get(nestId, options) {
+		return this.http.get(`${BASE$3}/${nestId}`, options);
+	}
+	async listEggs(nestId, options) {
+		return this.http.getList(`${BASE$3}/${nestId}/eggs`, options);
+	}
+	async getEgg(nestId, eggId, options) {
+		return this.http.get(`${BASE$3}/${nestId}/eggs/${eggId}`, options);
+	}
+};
+
+//#endregion
+//#region src/application/node-manager.ts
+const BASE$2 = "/api/application/nodes";
+var NodeManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(BASE$2, options);
+	}
+	async get(nodeId, options) {
+		return this.http.get(`${BASE$2}/${nodeId}`, options);
+	}
+	async getDeployable(options) {
+		return this.http.getList(`${BASE$2}/deployable`, options);
+	}
+	async create(params) {
+		return this.http.post(BASE$2, params);
+	}
+	async update(nodeId, params) {
+		return this.http.patch(`${BASE$2}/${nodeId}`, params);
+	}
+	async delete(nodeId) {
+		await this.http.delete(`${BASE$2}/${nodeId}`);
+	}
+	async getConfig(nodeId) {
+		return (await this.http.raw("GET", `${BASE$2}/${nodeId}/configuration`)).json();
+	}
+	async listAllocations(nodeId, options) {
+		return this.http.getList(`${BASE$2}/${nodeId}/allocations`, options);
+	}
+	async createAllocations(nodeId, params) {
+		await this.http.post(`${BASE$2}/${nodeId}/allocations`, params);
+	}
+	async deleteAllocation(nodeId, allocationId) {
+		await this.http.delete(`${BASE$2}/${nodeId}/allocations/${allocationId}`);
+	}
+};
+
+//#endregion
+//#region src/application/server-manager.ts
+const BASE$1 = "/api/application/servers";
+var ServerManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(BASE$1, options);
+	}
+	async get(serverId, options) {
+		return this.http.get(`${BASE$1}/${serverId}`, options);
+	}
+	async getByExternalId(externalId, options) {
+		return this.http.get(`${BASE$1}/external/${externalId}`, options);
+	}
+	async create(params) {
+		return this.http.post(BASE$1, params);
+	}
+	async updateDetails(serverId, params) {
+		return this.http.patch(`${BASE$1}/${serverId}/details`, params);
+	}
+	async updateBuild(serverId, params) {
+		return this.http.patch(`${BASE$1}/${serverId}/build`, params);
+	}
+	async updateStartup(serverId, params) {
+		return this.http.patch(`${BASE$1}/${serverId}/startup`, params);
+	}
+	async suspend(serverId) {
+		await this.http.post(`${BASE$1}/${serverId}/suspend`);
+	}
+	async unsuspend(serverId) {
+		await this.http.post(`${BASE$1}/${serverId}/unsuspend`);
+	}
+	async reinstall(serverId) {
+		await this.http.post(`${BASE$1}/${serverId}/reinstall`);
+	}
+	async delete(serverId) {
+		await this.http.delete(`${BASE$1}/${serverId}`);
+	}
+	async forceDelete(serverId) {
+		await this.http.delete(`${BASE$1}/${serverId}/force`);
+	}
+	async listDatabases(serverId, options) {
+		return this.http.getList(`${BASE$1}/${serverId}/databases`, options);
+	}
+	async getDatabase(serverId, databaseId, options) {
+		return this.http.get(`${BASE$1}/${serverId}/databases/${databaseId}`, options);
+	}
+	async createDatabase(serverId, params) {
+		return this.http.post(`${BASE$1}/${serverId}/databases`, params);
+	}
+	async resetDatabasePassword(serverId, databaseId) {
+		await this.http.post(`${BASE$1}/${serverId}/databases/${databaseId}/reset-password`);
+	}
+	async deleteDatabase(serverId, databaseId) {
+		await this.http.delete(`${BASE$1}/${serverId}/databases/${databaseId}`);
+	}
+};
+
+//#endregion
+//#region src/application/user-manager.ts
+const BASE = "/api/application/users";
+var UserManager = class {
+	constructor(http) {
+		this.http = http;
+	}
+	async list(options) {
+		return this.http.getList(BASE, options);
+	}
+	async get(userId, options) {
+		return this.http.get(`${BASE}/${userId}`, options);
+	}
+	async getByExternalId(externalId, options) {
+		return this.http.get(`${BASE}/external/${externalId}`, options);
+	}
+	async create(params) {
+		return this.http.post(BASE, params);
+	}
+	async update(userId, params) {
+		return this.http.patch(`${BASE}/${userId}`, params);
+	}
+	async delete(userId) {
+		await this.http.delete(`${BASE}/${userId}`);
+	}
+};
+
+//#endregion
+//#region src/application/index.ts
+var PteroApplication = class {
+	users;
+	servers;
+	nodes;
+	locations;
+	nests;
+	http;
+	constructor(options) {
+		this.http = new HttpClient(options);
+		this.users = new UserManager(this.http);
+		this.servers = new ServerManager(this.http);
+		this.nodes = new NodeManager(this.http);
+		this.locations = new LocationManager(this.http);
+		this.nests = new NestManager(this.http);
+	}
+	/** Current rate limit info from the last API response. */
+	get rateLimit() {
+		return this.http.rateLimit;
+	}
+};
+
+//#endregion
+//#region src/websocket/websocket-manager.ts
+var WebSocketManager = class {
+	ws = null;
+	listeners = /* @__PURE__ */ new Map();
+	reconnectAttempts = 0;
+	reconnectTimer = null;
+	intentionalClose = false;
+	origin;
+	serverUuid;
+	getToken;
+	maxReconnectDelay;
+	autoReconnect;
+	constructor(options) {
+		this.origin = options.origin.replace(/\/+$/, "");
+		this.serverUuid = options.serverUuid;
+		this.getToken = options.getToken;
+		this.maxReconnectDelay = options.maxReconnectDelay ?? 3e4;
+		this.autoReconnect = options.autoReconnect ?? true;
+	}
+	/** Connect to the WebSocket server. */
+	async connect() {
+		if (this.ws) return;
+		this.intentionalClose = false;
+		const token = await this.getToken();
+		const url = `${this.origin.startsWith("https") ? "wss" : "ws"}://${this.origin.replace(/^https?:\/\//, "")}/api/servers/${this.serverUuid}/ws`;
+		this.ws = new WebSocket(url);
+		this.ws.onopen = () => {
+			this.reconnectAttempts = 0;
+			this.sendAuth(token);
+		};
+		this.ws.onmessage = (event) => {
+			this.handleMessage(event.data);
+		};
+		this.ws.onclose = () => {
+			this.ws = null;
+			if (!this.intentionalClose && this.autoReconnect) this.scheduleReconnect();
+		};
+		this.ws.onerror = () => {};
+	}
+	/** Disconnect from the WebSocket server. */
+	disconnect() {
+		this.intentionalClose = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.ws) {
+			this.ws.close(1e3);
+			this.ws = null;
+		}
+		this.reconnectAttempts = 0;
+	}
+	/** Send a console command to the server. */
+	sendCommand(command) {
+		this.send("send command", [command]);
+	}
+	/** Send a power action to the server. */
+	sendPowerAction(action) {
+		this.send("set state", [action]);
+	}
+	/** Register an event handler. */
+	on(event, handler) {
+		let handlers = this.listeners.get(event);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			this.listeners.set(event, handlers);
+		}
+		handlers.add(handler);
+		return this;
+	}
+	/** Remove an event handler. */
+	off(event, handler) {
+		const handlers = this.listeners.get(event);
+		if (handlers) {
+			handlers.delete(handler);
+			if (handlers.size === 0) this.listeners.delete(event);
+		}
+		return this;
+	}
+	/** Whether the WebSocket is currently connected. */
+	get connected() {
+		return this.ws?.readyState === 1;
+	}
+	send(event, args) {
+		if (!this.ws || this.ws.readyState !== 1) return;
+		this.ws.send(JSON.stringify({
+			event,
+			args
+		}));
+	}
+	sendAuth(token) {
+		this.send("auth", [token]);
+	}
+	handleMessage(raw) {
+		let message;
+		try {
+			message = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		const { event, args } = message;
+		if (event === "token expiring") this.refreshToken();
+		this.emit(event, args);
+	}
+	emit(event, args) {
+		const handlers = this.listeners.get(event);
+		if (!handlers) return;
+		switch (event) {
+			case "auth success":
+			case "token expiring":
+			case "token expired":
+			case "install started":
+			case "install completed":
+				for (const handler of handlers) handler();
+				break;
+			case "stats": {
+				const statsJson = args?.[0];
+				if (statsJson) try {
+					const stats = JSON.parse(statsJson);
+					for (const handler of handlers) handler(stats);
+				} catch {}
+				break;
+			}
+			case "status": {
+				const status = args?.[0];
+				if (status) for (const handler of handlers) handler(status);
+				break;
+			}
+			default: {
+				const value = args?.[0];
+				if (value !== void 0) for (const handler of handlers) handler(value);
+				break;
+			}
+		}
+	}
+	async refreshToken() {
+		try {
+			const token = await this.getToken();
+			this.sendAuth(token);
+		} catch {}
+	}
+	scheduleReconnect() {
+		const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+		this.reconnectAttempts++;
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connect();
+		}, delay);
+	}
+};
+
+//#endregion
+//#region src/types/websocket.ts
+/** WebSocket close codes used by the Pterodactyl daemon. */
+let WebSocketCloseCode = /* @__PURE__ */ function(WebSocketCloseCode$1) {
+	WebSocketCloseCode$1[WebSocketCloseCode$1["Normal"] = 1e3] = "Normal";
+	WebSocketCloseCode$1[WebSocketCloseCode$1["GoingAway"] = 1001] = "GoingAway";
+	WebSocketCloseCode$1[WebSocketCloseCode$1["AbnormalClosure"] = 1006] = "AbnormalClosure";
+	WebSocketCloseCode$1[WebSocketCloseCode$1["AuthenticationFailed"] = 4001] = "AuthenticationFailed";
+	WebSocketCloseCode$1[WebSocketCloseCode$1["TokenExpired"] = 4004] = "TokenExpired";
+	return WebSocketCloseCode$1;
+}({});
+
+//#endregion
+export { AccountManager, BackupManager, DatabaseManager, FileManager, HttpClient, LocationManager, NestManager, NetworkManager, NodeManager, PteroApplication, PteroClient, PteroError, PteroRateLimitError, PteroValidationError, ScheduleManager, ServerContext, ServerManager, ServersManager, SubuserManager, UserManager, WebSocketCloseCode, WebSocketManager };