@screepts/screeps-api 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,978 @@
+import { Command } from "commander";
+import { EventEmitter } from "eventemitter3";
+import Debug from "debug";
+import { inflate } from "pako";
+import yaml from "js-yaml";
+import { readFile, writeFile } from "fs/promises";
+import { join, parse } from "path";
+//#region src/Socket.ts
+const debug = Debug("screepsapi:socket");
+const DEFAULTS$1 = {
+	reconnect: true,
+	resubscribe: true,
+	keepAlive: true,
+	maxRetries: 10,
+	maxRetryDelay: 60 * 1e3
+};
+var Socket = class extends EventEmitter {
+	ws;
+	api;
+	opts;
+	authed = false;
+	connected = false;
+	reconnecting = false;
+	keepAliveInter = 0;
+	__queue = [];
+	__subQueue = [];
+	__subs = {};
+	constructor(api) {
+		super();
+		this.api = api;
+		this.opts = Object.assign({}, DEFAULTS$1);
+		this.on("error", () => {});
+		this.reset();
+		this.on("auth", (ev) => {
+			if (ev.data.status === "ok") {
+				while (this.__queue.length) this.ws?.send(this.__queue.shift());
+				clearInterval(this.keepAliveInter);
+				if (this.opts.keepAlive) this.keepAliveInter = setInterval(() => this.ws && this.ws.send(""), 1e4);
+			}
+		});
+	}
+	reset() {
+		this.authed = false;
+		this.connected = false;
+		this.reconnecting = false;
+		clearInterval(this.keepAliveInter);
+		this.keepAliveInter = 0;
+		this.__queue = [];
+		this.__subQueue = [];
+		this.__subs = {};
+	}
+	async connect(opts = {}) {
+		Object.assign(this.opts, opts);
+		if (!this.api.token) throw new Error("No token! Call api.auth() before connecting the socket!");
+		return new Promise((resolve, reject) => {
+			const baseURL = this.api.opts.url.replace("http", "ws");
+			const wsurl = new URL("socket/websocket", baseURL);
+			this.ws = new WebSocket(wsurl);
+			this.ws.addEventListener("open", () => {
+				this.connected = true;
+				this.reconnecting = false;
+				if (this.opts.resubscribe) this.__subQueue.push(...Object.keys(this.__subs));
+				debug("connected");
+				this.emit("connected");
+				resolve(this.auth(this.api.token));
+			});
+			this.ws.onclose = () => {
+				clearInterval(this.keepAliveInter);
+				this.authed = false;
+				this.connected = false;
+				debug("disconnected");
+				this.emit("disconnected");
+				if (this.opts.reconnect) this.reconnect().catch(() => {});
+			};
+			this.ws.addEventListener("error", (err) => {
+				this.ws?.close();
+				this.emit("error", err);
+				debug(`error ${err.error || err}`);
+				if (!this.connected) reject(err);
+			});
+			this.ws.addEventListener("message", (data) => this.handleMessage(data));
+		});
+	}
+	async reconnect() {
+		if (this.reconnecting) return;
+		this.reconnecting = true;
+		let retries = 0;
+		let retry;
+		do {
+			let time = Math.pow(2, retries) * 100;
+			if (time > this.opts.maxRetryDelay) time = this.opts.maxRetryDelay;
+			await this.sleep(time);
+			if (!this.reconnecting) return;
+			try {
+				await this.connect();
+				retry = false;
+			} catch {
+				retry = true;
+			}
+			retries++;
+			debug(`reconnect ${retries}/${this.opts.maxRetries}`);
+		} while (retry && retries < this.opts.maxRetries);
+		if (retry) {
+			const err = /* @__PURE__ */ new Error(`Reconnection failed after ${this.opts.maxRetries} retries`);
+			this.reconnecting = false;
+			debug("reconnect failed");
+			this.emit("error", err);
+			throw err;
+		} else Object.keys(this.__subs).forEach((sub) => this.subscribe(sub));
+	}
+	disconnect() {
+		debug("disconnect");
+		clearInterval(this.keepAliveInter);
+		if (this.ws) {
+			this.ws.onclose = null;
+			this.ws.close();
+		}
+		this.reset();
+		this.emit("disconnected");
+	}
+	sleep(time) {
+		return new Promise((resolve) => setTimeout(resolve, time));
+	}
+	handleMessage(ev) {
+		const msg = this.api.gz(ev.data || ev);
+		debug(`message ${msg}`);
+		if (msg[0] === "[") {
+			const arr = JSON.parse(msg);
+			let [, type, id, channel] = arr[0].match(/^(.+):(.+?)(?:\/(.+))?$/);
+			channel = channel || type;
+			const event = {
+				channel,
+				id,
+				type,
+				data: arr[1]
+			};
+			this.emit(msg[0], event);
+			this.emit(event.channel, event);
+			this.emit("message", event);
+		} else {
+			const [channel, ...data] = msg.split(" ");
+			const event = {
+				type: "server",
+				channel,
+				data
+			};
+			if (channel === "auth") event.data = {
+				status: data[0],
+				token: data[1]
+			};
+			if ([
+				"protocol",
+				"time",
+				"package"
+			].includes(channel)) event.data = { [channel]: data[0] };
+			this.emit(channel, event);
+			this.emit("message", event);
+		}
+	}
+	async gzip(bool) {
+		await this.send(`gzip ${bool ? "on" : "off"}`);
+	}
+	async send(data) {
+		if (!this.connected) this.__queue.push(data);
+		else this.ws.send(data);
+	}
+	async auth(token) {
+		const waitAuth = new Promise((resolve) => this.once("auth", resolve));
+		await this.send(`auth ${token}`);
+		const { data } = await waitAuth;
+		if (data.status !== "ok") throw new Error("socket auth failed");
+		this.authed = true;
+		this.emit("token", data.token);
+		this.emit("authed");
+		while (this.__subQueue.length) await this.send(this.__subQueue.shift());
+	}
+	async subscribe(path, cb) {
+		if (!path) return;
+		const userID = await this.api.userID();
+		if (!path.match(/^(\w+):(.+?)$/)) path = `user:${userID}/${path}`;
+		if (this.authed) await this.send(`subscribe ${path}`);
+		else this.__subQueue.push(`subscribe ${path}`);
+		this.emit("subscribe", path);
+		this.__subs[path] = this.__subs[path] || 0;
+		this.__subs[path]++;
+		if (cb) this.on(path, cb);
+	}
+	async unsubscribe(path) {
+		if (!path) return;
+		const userID = await this.api.userID();
+		if (!path.match(/^(\w+):(.+?)$/)) path = `user:${userID}/${path}`;
+		await this.send(`unsubscribe ${path}`);
+		this.emit("unsubscribe", path);
+		if (this.__subs[path]) this.__subs[path]--;
+	}
+};
+//#endregion
+//#region src/RawAPI.ts
+const debugHttp = Debug("screepsapi:http");
+const debugRateLimit = Debug("screepsapi:ratelimit");
+const DEFAULT_SHARD = "shard0";
+const OFFICIAL_HISTORY_INTERVAL = 100;
+const PRIVATE_HISTORY_INTERVAL = 20;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const mapToShard = (res) => {
+	if (!res.shards) res.shards = { privSrv: res.list || res.rooms };
+	return res;
+};
+var RawAPI = class extends EventEmitter {
+	opts;
+	token;
+	__authed = false;
+	constructor(opts = {}) {
+		super();
+		this.opts = {};
+		this.setServer(opts);
+	}
+	raw = {
+		token: void 0,
+		version: () => this.req("GET", "/api/version"),
+		authmod: () => {
+			if (this.isOfficialServer()) return Promise.resolve({
+				ok: 1,
+				name: "official"
+			});
+			return this.req("GET", "/api/authmod");
+		},
+		history: (room, tick, shard = DEFAULT_SHARD) => {
+			if (this.isOfficialServer()) {
+				tick -= tick % OFFICIAL_HISTORY_INTERVAL;
+				return this.req("GET", `/room-history/${shard}/${room}/${tick}.json`);
+			} else {
+				tick -= tick % PRIVATE_HISTORY_INTERVAL;
+				return this.req("GET", "/room-history", {
+					room,
+					time: tick
+				});
+			}
+		},
+		servers: { list: () => this.req("POST", "/api/servers/list", {}) },
+		auth: {
+			signin: (email, password) => this.req("POST", "/api/auth/signin", {
+				email,
+				password
+			}),
+			steamTicket: (ticket, useNativeAuth = false) => this.req("POST", "/api/auth/steam-ticket", {
+				ticket,
+				useNativeAuth
+			}),
+			me: () => this.req("GET", "/api/auth/me"),
+			queryToken: (token) => this.req("GET", "/api/auth/query-token", { token })
+		},
+		register: {
+			checkEmail: (email) => this.req("GET", "/api/register/check-email", { email }),
+			checkUsername: (username) => this.req("GET", "/api/register/check-username", { username }),
+			setUsername: (username) => this.req("POST", "/api/register/set-username", { username }),
+			submit: (username, email, password, modules) => this.req("POST", "/api/register/submit", {
+				username,
+				email,
+				password,
+				modules
+			})
+		},
+		userMessages: {
+			list: (respondent) => this.req("GET", "/api/user/messages/list", { respondent }),
+			index: () => this.req("GET", "/api/user/messages/index"),
+			unreadCount: () => this.req("GET", "/api/user/messages/unread-count"),
+			send: (respondent, text) => this.req("POST", "/api/user/messages/send", {
+				respondent,
+				text
+			}),
+			markRead: (id) => this.req("POST", "/api/user/messages/mark-read", { id })
+		},
+		game: {
+			mapStats: (rooms, statName, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/map-stats", {
+				rooms,
+				statName,
+				shard
+			}),
+			genUniqueObjectName: (type, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/gen-unique-object-name", {
+				type,
+				shard
+			}),
+			checkUniqueObjectName: (type, name, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/check-unique-object-name", {
+				type,
+				name,
+				shard
+			}),
+			placeSpawn: (room, x, y, name, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/place-spawn", {
+				name,
+				room,
+				x,
+				y,
+				shard
+			}),
+			createFlag: (room, x, y, name, color = 1, secondaryColor = 1, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/create-flag", {
+				name,
+				room,
+				x,
+				y,
+				color,
+				secondaryColor,
+				shard
+			}),
+			genUniqueFlagName: (shard = DEFAULT_SHARD) => this.req("POST", "/api/game/gen-unique-flag-name", { shard }),
+			checkUniqueFlagName: (name, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/check-unique-flag-name", {
+				name,
+				shard
+			}),
+			changeFlagColor: (color = 1, secondaryColor = 1, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/change-flag-color", {
+				color,
+				secondaryColor,
+				shard
+			}),
+			removeFlag: (room, name, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/remove-flag", {
+				name,
+				room,
+				shard
+			}),
+			addObjectIntent: (room, name, intent, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/add-object-intent", {
+				room,
+				name,
+				intent,
+				shard
+			}),
+			createConstruction: (room, x, y, structureType, name, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/create-construction", {
+				room,
+				x,
+				y,
+				structureType,
+				name,
+				shard
+			}),
+			setNotifyWhenAttacked: (_id, enabled = true, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/set-notify-when-attacked", {
+				_id,
+				enabled,
+				shard
+			}),
+			createInvader: (room, x, y, size, type, boosted = false, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/create-invader", {
+				room,
+				x,
+				y,
+				size,
+				type,
+				boosted,
+				shard
+			}),
+			removeInvader: (_id, shard = DEFAULT_SHARD) => this.req("POST", "/api/game/remove-invader", {
+				_id,
+				shard
+			}),
+			time: (shard = DEFAULT_SHARD) => this.req("GET", "/api/game/time", { shard }),
+			worldSize: (shard = DEFAULT_SHARD) => this.req("GET", "/api/game/world-size", { shard }),
+			roomDecorations: (room, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/room-decorations", {
+				room,
+				shard
+			}),
+			roomObjects: (room, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/room-objects", {
+				room,
+				shard
+			}),
+			roomTerrain: (room, encoded = 1, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/room-terrain", {
+				room,
+				encoded,
+				shard
+			}),
+			roomStatus: (room, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/room-status", {
+				room,
+				shard
+			}),
+			roomOverview: (room, interval = 8, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/room-overview", {
+				room,
+				interval,
+				shard
+			}),
+			market: {
+				ordersIndex: (shard = DEFAULT_SHARD) => this.req("GET", "/api/game/market/orders-index", { shard }),
+				myOrders: () => this.req("GET", "/api/game/market/my-orders").then(mapToShard),
+				orders: (resourceType, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/market/orders", {
+					resourceType,
+					shard
+				}),
+				stats: (resourceType, shard = DEFAULT_SHARD) => this.req("GET", "/api/game/market/stats", {
+					resourceType,
+					shard
+				})
+			},
+			shards: { info: () => this.req("GET", "/api/game/shards/info") }
+		},
+		leaderboard: {
+			list: (limit = 10, mode = "world", offset = 0, season) => {
+				if (mode !== "world" && mode !== "power") throw new Error("incorrect mode parameter");
+				if (!season) season = this.currentSeason();
+				return this.req("GET", "/api/leaderboard/list", {
+					limit,
+					mode,
+					offset,
+					season
+				});
+			},
+			find: (username, mode = "world", season = "") => this.req("GET", "/api/leaderboard/find", {
+				season,
+				mode,
+				username
+			}),
+			seasons: () => this.req("GET", "/api/leaderboard/seasons")
+		},
+		user: {
+			badge: (badge) => this.req("POST", "/api/user/badge", { badge }),
+			respawn: () => this.req("POST", "/api/user/respawn"),
+			setActiveBranch: (branch, activeName) => this.req("POST", "/api/user/set-active-branch", {
+				branch,
+				activeName
+			}),
+			cloneBranch: (branch = "", newName, defaultModules) => this.req("POST", "/api/user/clone-branch", {
+				branch,
+				newName,
+				defaultModules
+			}),
+			deleteBranch: (branch) => this.req("POST", "/api/user/delete-branch", { branch }),
+			notifyPrefs: (prefs) => this.req("POST", "/api/user/notify-prefs", prefs),
+			tutorialDone: () => this.req("POST", "/api/user/tutorial-done"),
+			email: (email) => this.req("POST", "/api/user/email", { email }),
+			worldStartRoom: (shard) => this.req("GET", "/api/user/world-start-room", { shard }),
+			worldStatus: () => this.req("GET", "/api/user/world-status"),
+			branches: () => this.req("GET", "/api/user/branches"),
+			code: {
+				get: (branch) => this.req("GET", "/api/user/code", { branch }),
+				set: (branch, modules, _hash) => {
+					if (!_hash) _hash = Date.now();
+					return this.req("POST", "/api/user/code", {
+						branch,
+						modules,
+						_hash
+					});
+				}
+			},
+			decorations: {
+				inventory: () => this.req("GET", "/api/user/decorations/inventory"),
+				themes: () => this.req("GET", "/api/user/decorations/themes"),
+				convert: (decorations) => this.req("POST", "/api/user/decorations/convert", { decorations }),
+				pixelize: (count, theme = "") => this.req("POST", "/api/user/decorations/pixelize", {
+					count,
+					theme
+				}),
+				activate: (_id, active) => this.req("POST", "/api/user/decorations/activate", {
+					_id,
+					active
+				}),
+				deactivate: (decorations) => this.req("POST", "/api/user/decorations/deactivate", { decorations })
+			},
+			respawnProhibitedRooms: () => this.req("GET", "/api/user/respawn-prohibited-rooms"),
+			memory: {
+				get: (path = "", shard = DEFAULT_SHARD) => this.req("GET", "/api/user/memory", {
+					path,
+					shard
+				}),
+				set: (path, value, shard = DEFAULT_SHARD) => this.req("POST", "/api/user/memory", {
+					path,
+					value,
+					shard
+				}),
+				segment: {
+					get: (segment, shard = DEFAULT_SHARD) => this.req("GET", "/api/user/memory-segment", {
+						segment,
+						shard
+					}),
+					set: (segment, data, shard = DEFAULT_SHARD) => this.req("POST", "/api/user/memory-segment", {
+						segment,
+						data,
+						shard
+					})
+				}
+			},
+			find: (username) => this.req("GET", "/api/user/find", { username }),
+			findById: (id) => this.req("GET", "/api/user/find", { id }),
+			stats: (interval) => this.req("GET", "/api/user/stats", { interval }),
+			rooms: (id) => this.req("GET", "/api/user/rooms", { id }).then(mapToShard),
+			overview: (interval, statName) => this.req("GET", "/api/user/overview", {
+				interval,
+				statName
+			}),
+			moneyHistory: (page = 0) => this.req("GET", "/api/user/money-history", { page }),
+			console: (expression, shard = DEFAULT_SHARD) => this.req("POST", "/api/user/console", {
+				expression,
+				shard
+			}),
+			name: () => this.req("GET", "/api/user/name")
+		},
+		experimental: {
+			pvp: (interval = 100) => this.req("GET", "/api/experimental/pvp", { interval }).then(mapToShard),
+			nukes: () => this.req("GET", "/api/experimental/nukes").then(mapToShard)
+		},
+		warpath: { battles: (interval = 100) => this.req("GET", "/api/warpath/battles", { interval }) },
+		scoreboard: { list: (limit = 20, offset = 0) => this.req("GET", "/api/scoreboard/list", {
+			limit,
+			offset
+		}) }
+	};
+	currentSeason() {
+		const now = /* @__PURE__ */ new Date();
+		const year = now.getFullYear();
+		let month = (now.getUTCMonth() + 1).toString();
+		if (month.length === 1) month = `0${month}`;
+		return `${year}-${month}`;
+	}
+	isOfficialServer() {
+		return this.opts.url.match(/screeps\.com/) !== null;
+	}
+	mapToShard = mapToShard;
+	setServer(opts) {
+		if (!this.opts) this.opts = {};
+		Object.assign(this.opts, opts);
+		if (opts.path && !opts.pathname) this.opts.pathname = opts.path;
+		if (opts.port) {
+			this.opts.port = String(opts.port);
+			if (opts.hostname) this.opts.host = `${opts.hostname}:${opts.port}`;
+		}
+		if (!opts.url) {
+			this.opts.url = urlFormat(this.opts);
+			if (!this.opts.url.endsWith("/")) this.opts.url += "/";
+		}
+		if (opts.token) this.token = opts.token;
+	}
+	async auth(email, password, opts = {}) {
+		this.setServer(opts);
+		if (email && password) Object.assign(this.opts, {
+			email,
+			password
+		});
+		const res = await this.raw.auth.signin(this.opts.email, this.opts.password);
+		this.emit("token", res.token);
+		this.emit("auth");
+		this.__authed = true;
+		return res;
+	}
+	async req(method, path, body = {}) {
+		let url = new URL(path, this.opts.url);
+		const opts = {
+			method,
+			headers: {}
+		};
+		if (debugHttp.enabled) debugHttp(`${method} ${path}`);
+		if (this.token) Object.assign(opts.headers, {
+			"X-Token": this.token,
+			"X-Username": this.token
+		});
+		if (method === "GET") Object.entries(body).forEach(([key, value]) => {
+			if (value !== void 0) url.searchParams.append(key, String(value));
+		});
+		else {
+			opts.body = body;
+			if (typeof body === "object") {
+				opts.body = JSON.stringify(body);
+				opts.headers["Content-Type"] = "application/json";
+			}
+		}
+		const res = await fetch(url, opts);
+		const token = res.headers.get("x-token");
+		if (token) this.emit("token", token);
+		const rateLimit = this.buildRateLimit(method, path, res);
+		this.emit("rateLimit", rateLimit);
+		debugRateLimit(`${method} ${path} ${rateLimit.remaining}/${rateLimit.limit} ${rateLimit.toReset}s`);
+		if (res.headers.get("content-type")?.includes("application/json")) res.data = await res.json();
+		else res.data = await res.text();
+		if (!res.ok) {
+			if (res.status === 401) if (this.__authed && this.opts.email && this.opts.password) {
+				this.__authed = false;
+				await this.auth(this.opts.email, this.opts.password);
+				return this.req(method, path, body);
+			} else throw new Error("Not Authorized");
+			else if (res.status === 429 && !res.headers.get("x-ratelimit-limit") && this.opts.experimentalRetry429) {
+				await sleep(Math.floor(Math.random() * 500) + 200);
+				return this.req(method, path, body);
+			}
+			throw new Error(res.data);
+		}
+		this.emit("response", res);
+		return res.data;
+	}
+	gz(data) {
+		if (!data.startsWith("gz:")) return data;
+		return inflate(Buffer.from(data.slice(3), "base64"), { to: "string" });
+	}
+	inflate(data) {
+		return JSON.parse(this.gz(data));
+	}
+	buildRateLimit(method, path, res) {
+		const limit = Number(res.headers.get("x-ratelimit-limit"));
+		const remaining = Number(res.headers.get("x-ratelimit-remaining"));
+		const reset = Number(res.headers.get("x-ratelimit-reset"));
+		return {
+			method,
+			path,
+			limit,
+			remaining,
+			reset,
+			toReset: reset - Math.floor(Date.now() / 1e3)
+		};
+	}
+};
+/** Based on Node.js built-in URL format */
+function urlFormat(obj) {
+	let protocol = obj.protocol || "";
+	if (protocol && !protocol.endsWith(":")) protocol += ":";
+	let pathname = obj.pathname || "";
+	let host = "";
+	if (obj.host) host = obj.host;
+	else if (obj.hostname) {
+		host = obj.hostname.includes(":") && (obj.hostname[0] !== "[" || obj.hostname[obj.hostname.length - 1] !== "]") ? "[" + obj.hostname + "]" : obj.hostname;
+		if (obj.port) host += ":" + obj.port;
+	}
+	if (pathname.includes("#") || pathname.includes("?")) {
+		let newPathname = "";
+		let lastPos = 0;
+		const len = pathname.length;
+		for (let i = 0; i < len; i++) {
+			const code = pathname.charAt(i);
+			if (code === "#" || code === "?") {
+				if (i > lastPos) newPathname += pathname.slice(lastPos, i);
+				newPathname += code === "#" ? "%23" : "%3F";
+				lastPos = i + 1;
+			}
+		}
+		if (lastPos < len) newPathname += pathname.slice(lastPos);
+		pathname = newPathname;
+	}
+	if (host) {
+		if (pathname && pathname[0] !== "/") pathname = "/" + pathname;
+		host = "//" + host;
+	}
+	return protocol + host + pathname;
+}
+//#endregion
+//#region src/ConfigManager.ts
+/**
+* Utility class for loading Unified Credentials Files from disk, environment variables, or other sources.
+* Only platforms without filesystem access, {@link ConfigManager.setConfig}, must be used to provide the config data directly.
+*/
+var ConfigManager = class {
+	path;
+	_config = null;
+	/** Custom environment variables, useful for platforms without process.env */
+	env = globalThis.process?.env || {};
+	/** Custom file reading function, useful for platforms with a virtual filesystem */
+	readFile;
+	setConfig(data, path) {
+		if (!data || typeof data !== "object" || !("servers" in data)) throw new Error(`Invalid config: 'servers' object does not exist in '${path}'`);
+		this._config = data;
+		this.path = path;
+		return this._config;
+	}
+	async refresh() {
+		this._config = null;
+		await this.getConfig();
+	}
+	async getServers() {
+		const conf = await this.getConfig();
+		return conf ? Object.keys(conf.servers) : [];
+	}
+	async getConfig() {
+		if (this._config) return this._config;
+		const paths = [];
+		if (this.env.SCREEPS_CONFIG) paths.push(this.env.SCREEPS_CONFIG);
+		const dirs = ["", import.meta.dirname];
+		for (const dir of dirs) {
+			paths.push(join$1(dir, ".screeps.yaml"));
+			paths.push(join$1(dir, ".screeps.yml"));
+		}
+		if (process.platform === "win32" && this.env.APPDATA) {
+			paths.push(join$1(this.env.APPDATA, "screeps/config.yaml"));
+			paths.push(join$1(this.env.APPDATA, "screeps/config.yml"));
+		} else {
+			if (this.env.XDG_CONFIG_HOME) {
+				paths.push(join$1(this.env.XDG_CONFIG_HOME, "screeps/config.yaml"));
+				paths.push(join$1(this.env.XDG_CONFIG_HOME, "screeps/config.yml"));
+			}
+			if (this.env.HOME) {
+				paths.push(join$1(this.env.HOME, ".config/screeps/config.yaml"));
+				paths.push(join$1(this.env.HOME, ".config/screeps/config.yml"));
+				paths.push(join$1(this.env.HOME, ".screeps.yaml"));
+				paths.push(join$1(this.env.HOME, ".screeps.yml"));
+			}
+		}
+		for (const path of paths) {
+			const data = await this.loadConfig(path);
+			if (data) return data;
+		}
+		return null;
+	}
+	async loadConfig(path) {
+		if (!this.readFile) {
+			const { readFile } = await import("fs/promises");
+			this.readFile = readFile;
+		}
+		let contents;
+		try {
+			contents = await this.readFile(path, { encoding: "utf8" });
+		} catch (e) {
+			if (e.code === "ENOENT") return null;
+			else throw e;
+		}
+		const data = yaml.load(contents);
+		return this.setConfig(data, path);
+	}
+};
+function join$1(a, b) {
+	return a + (a.endsWith("/") ? "" : "/") + b;
+}
+//#endregion
+//#region src/ScreepsAPI.ts
+const DEFAULTS = {
+	protocol: "https",
+	hostname: "screeps.com",
+	port: 443,
+	path: "/"
+};
+const configManager = new ConfigManager();
+var ScreepsAPI = class ScreepsAPI extends RawAPI {
+	socket;
+	appConfig = {};
+	rateLimits;
+	_user;
+	_tokenInfo;
+	static async fromConfig(server = "main", config = false, opts = {}) {
+		const data = await configManager.getConfig();
+		if (!data) throw new Error("No valid config found");
+		if (!server && process.stdin.isTTY && process.stdout.isTTY) {
+			const { select, isCancel } = await import("@clack/prompts");
+			const selectedServer = await select({
+				message: "Select a server:",
+				withGuide: false,
+				options: Object.entries(data.servers).map(([value, args]) => ({
+					value,
+					hint: args.host
+				}))
+			});
+			if (isCancel(selectedServer)) throw new Error("Server selection cancelled");
+			server = selectedServer;
+		}
+		const conf = data.servers[server];
+		if (!conf) throw new Error(`Server '${server}' does not exist in '${configManager.path}'`);
+		if (conf.ptr) conf.path = "/ptr";
+		if (conf.season) conf.path = "/season";
+		const api = new ScreepsAPI(Object.assign({
+			hostname: conf.host,
+			protocol: conf.secure ? "https" : "http",
+			path: "/"
+		}, conf, opts));
+		api.appConfig = data.configs && data.configs[config] || {};
+		if (!conf.token && conf.username && conf.password) await api.auth(conf.username, conf.password);
+		return api;
+	}
+	constructor(opts = {}) {
+		opts = Object.assign({}, DEFAULTS, opts);
+		super(opts);
+		this.on("token", (token) => {
+			this.token = token;
+			this.raw.token = token;
+		});
+		const defaultLimit = (limit, period) => ({
+			limit,
+			period,
+			remaining: limit,
+			reset: 0,
+			toReset: 0
+		});
+		this.rateLimits = {
+			global: defaultLimit(120, "minute"),
+			GET: {
+				"/api/game/room-terrain": defaultLimit(360, "hour"),
+				"/api/user/code": defaultLimit(60, "hour"),
+				"/api/user/memory": defaultLimit(1440, "day"),
+				"/api/user/memory-segment": defaultLimit(360, "hour"),
+				"/api/game/market/orders-index": defaultLimit(60, "hour"),
+				"/api/game/market/orders": defaultLimit(60, "hour"),
+				"/api/game/market/my-orders": defaultLimit(60, "hour"),
+				"/api/game/market/stats": defaultLimit(60, "hour"),
+				"/api/game/user/money-history": defaultLimit(60, "hour")
+			},
+			POST: {
+				"/api/user/console": defaultLimit(360, "hour"),
+				"/api/game/map-stats": defaultLimit(60, "hour"),
+				"/api/user/code": defaultLimit(240, "day"),
+				"/api/user/set-active-branch": defaultLimit(240, "day"),
+				"/api/user/memory": defaultLimit(240, "day"),
+				"/api/user/memory-segment": defaultLimit(60, "hour")
+			}
+		};
+		this.on("rateLimit", (limits) => {
+			const rate = this.rateLimits[limits.method]?.[limits.path] || this.rateLimits.global;
+			const copy = Object.assign({}, limits);
+			delete copy.path;
+			delete copy.method;
+			Object.assign(rate, copy);
+		});
+		this.socket = new Socket(this);
+	}
+	getRateLimit(method, path) {
+		return this.rateLimits[method][path] || this.rateLimits.global;
+	}
+	get rateLimitResetUrl() {
+		return `https://screeps.com/a/#!/account/auth-tokens/noratelimit?token=${this.token.slice(0, 8)}`;
+	}
+	async me() {
+		if (this._user) return this._user;
+		if ((await this.tokenInfo()).full) this._user = await this.raw.auth.me();
+		else {
+			const { username } = await this.raw.user.name();
+			const { ok, user } = await this.raw.user.find(username);
+			this._user = {
+				...user,
+				ok
+			};
+		}
+		return this._user;
+	}
+	async tokenInfo() {
+		if (this._tokenInfo) return this._tokenInfo;
+		if ("token" in this.opts) {
+			const { token } = await this.raw.auth.queryToken(this.token);
+			this._tokenInfo = token;
+		} else this._tokenInfo = { full: true };
+		return this._tokenInfo;
+	}
+	async userID() {
+		return (await this.me())._id;
+	}
+	registerUser = this.raw.register.submit;
+	history = this.raw.history;
+	authmod = this.raw.authmod;
+	version = this.raw.version;
+	time = this.raw.game.time;
+	leaderboard = this.raw.leaderboard;
+	market = this.raw.game.market;
+	console = this.raw.user.console;
+	code = codeRepository(this);
+	memory = {
+		...this.raw.user.memory,
+		get: async (path, shard) => {
+			const { data } = await this.raw.user.memory.get(path, shard);
+			return this.gz(data);
+		}
+	};
+	segment = this.raw.user.memory.segment;
+};
+const codeRepository = ({ raw: { user } }) => ({
+	get: user.code.get,
+	set: async (branch, code) => {
+		const { list } = await user.branches();
+		if (list.some((b) => b.branch == branch)) return user.code.set(branch, code);
+		else return user.cloneBranch("", branch, code);
+	},
+	branches: user.branches,
+	cloneBranch: user.cloneBranch,
+	deleteBranch: user.deleteBranch,
+	setActiveBranch: user.setActiveBranch
+});
+//#endregion
+//#region package.json
+var version = "1.0.0";
+//#endregion
+//#region src/cli.ts
+async function init(opts) {
+	return ScreepsAPI.fromConfig(opts.server);
+}
+async function out(data) {
+	data = await data;
+	data = data && data.data || data;
+	if (process.stdout.isTTY) console.log(data);
+	else process.stdout.write(JSON.stringify(data));
+}
+async function run() {
+	const program = new Command();
+	/** @param {string} name */
+	const commandBase = (name, args = "") => {
+		const command = new Command(name);
+		command.arguments(args).option("--server <server>", "Server config to use", "");
+		program.addCommand(command);
+		return command;
+	};
+	program.version(version);
+	commandBase("raw", "<cmd> [args...]").description("Execute raw API call").action(async function(cmd, args, opts) {
+		try {
+			const api = await init(opts);
+			const path = cmd.split(".");
+			let fn = api.raw;
+			for (const part of path) fn = fn[part];
+			if (!fn || typeof fn !== "function") {
+				console.log("Invalid cmd");
+				return;
+			}
+			await out(fn.apply(api, args));
+		} catch (e) {
+			console.error(e);
+		}
+	});
+	commandBase("memory", "[path]").description(`Get Memory contents`).option("--set <file>", "Sets the memory path to the contents of file").option("--allow-root", "Allows writing without path").option("-s --shard <shard>", "Shard to read from", "shard0").option("-f --file <file>", "File to write data to").action(async function(fpath, opts) {
+		try {
+			const api = await init(opts);
+			if (opts.set) {
+				if (!fpath && !opts.allowRoot) throw new Error("Refusing to write to root! Use --allow-root if you really want this.");
+				const data = await readFile(opts.set, "utf8");
+				await api.memory.set(fpath, data, opts.shard);
+				await out("Memory written");
+			} else {
+				const data = await api.memory.get(fpath, opts.shard);
+				if (opts.file) await writeFile(opts.file, data);
+				else await out(data);
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	});
+	commandBase("segment", "<segment>").description(`Get segment contents. Use 'all' to get all)`).option("--set <file>", "Sets the segment content to the contents of file").option("-s --shard <shard>", "Shard to read from", "shard0").option("-d --dir <dir>", "Directory to save in. Empty files are not written. (defaults to outputing in console)").action(async function(segment, opts) {
+		try {
+			const api = await init(opts);
+			if (opts.set) {
+				const data = await readFile(opts.set, "utf8");
+				await api.memory.segment.set(segment, data, opts.shard);
+				await out("Segment Set");
+			} else {
+				if (segment === "all") segment = Array.from({ length: 100 }, (v, k) => k).join(",");
+				const { data } = await api.memory.segment.get(segment, opts.shard);
+				const dir = opts.dir;
+				const segments = data;
+				if (dir) {
+					if (Array.isArray(segments)) await Promise.all(segments.map((d, i) => d && writeFile(join(dir, `segment_${i}`), d)));
+					else await writeFile(join(dir, `segment_${segment}`), data);
+					await out("Segments Saved");
+				} else await out(segments);
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	});
+	commandBase("download").description(`Download code`).option("-b --branch <branch>", "Code branch", "default").option("-d --dir <dir>", "Directory to save in (defaults to outputing in console)").action(async function(opts) {
+		try {
+			const api = await init(opts);
+			const dir = opts.dir;
+			const { modules } = await api.code.get(opts.branch);
+			if (dir) await Promise.all(Object.keys(modules).map(async (fn) => {
+				const data = modules[fn];
+				if (typeof data === "string") await writeFile(join(dir, `${fn}.js`), data);
+				else await writeFile(join(dir, `${fn}.wasm`), Buffer.from(data.binary, "base64"));
+				console.log(`Saved ${fn}`);
+			}));
+			else await out(modules);
+		} catch (e) {
+			console.error(e);
+		}
+	});
+	commandBase("upload", "<files...>").description(`Upload code`).option("-b --branch <branch>", "Code branch", "default").action(async function(files, opts) {
+		try {
+			const api = await init(opts);
+			const modules = {};
+			const ps = [];
+			for (const file of files) ps.push((async (file) => {
+				const { name, ext } = parse(file);
+				const data = await readFile(file);
+				if (ext === ".js") modules[name] = data.toString("utf8");
+				if (ext === ".wasm") modules[name] = { binary: data.toString("base64") };
+			})(file));
+			await Promise.all(ps);
+			await out(api.code.set(opts.branch, modules));
+		} catch (e) {
+			console.error(e);
+		}
+	});
+	if (!process.argv.slice(2).length) program.outputHelp();
+	await program.parseAsync();
+}
+run().then((data) => {
+	if (!data) return;
+	console.log(JSON.stringify(data.data || data, null, 2));
+}).catch(console.error);
+//#endregion
+export {};