@remote-app/qbittorrent-client 0.22.0

package/dist/index.mjs

@@ -0,0 +1,271 @@
+//#region src/error.ts
+var HTTPError = class extends Error {
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "HTTPError";
+	}
+};
+var QBittorrentError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "QBittorrentError";
+	}
+};
+
+//#endregion
+//#region src/client.ts
+var QBittorrentClient = class {
+	constructor(config) {
+		this.config = config;
+		this.sid = null;
+		this.loggedIn = false;
+		this.loginPromise = null;
+	}
+	baseUrl() {
+		return this.config.url.replace(/\/+$/, "");
+	}
+	async login() {
+		if (this.loginPromise) return this.loginPromise;
+		this.loginPromise = this.doLogin();
+		try {
+			await this.loginPromise;
+		} finally {
+			this.loginPromise = null;
+		}
+	}
+	async doLogin() {
+		const baseUrl = this.baseUrl();
+		const body = new URLSearchParams();
+		if (this.config.username) body.set("username", this.config.username);
+		if (this.config.password) body.set("password", this.config.password);
+		const response = await fetch(`${baseUrl}/api/v2/auth/login`, {
+			method: "POST",
+			headers: {
+				Referer: baseUrl,
+				"Content-Type": "application/x-www-form-urlencoded"
+			},
+			credentials: "include",
+			body: body.toString()
+		});
+		if (!response.ok) throw new HTTPError(response.status, response.statusText);
+		if (await response.text() !== "Ok.") throw new QBittorrentError("Login failed: invalid credentials");
+		const cookie = response.headers.get("set-cookie");
+		if (cookie) {
+			const match = cookie.match(/SID=([^;]+)/);
+			if (match) this.sid = match[1];
+		}
+		this.loggedIn = true;
+	}
+	async get(path, params) {
+		return this.request("GET", path, params);
+	}
+	async post(path, body) {
+		return this.request("POST", path, void 0, body);
+	}
+	async request(method, path, params, body, retry = true) {
+		if (!this.loggedIn) await this.login();
+		const baseUrl = this.baseUrl();
+		let url = `${baseUrl}${path}`;
+		if (params) {
+			const qs = new URLSearchParams(params);
+			url += `?${qs.toString()}`;
+		}
+		const headers = { Referer: baseUrl };
+		if (this.sid) headers["Cookie"] = `SID=${this.sid}`;
+		let fetchBody;
+		if (body instanceof URLSearchParams) {
+			headers["Content-Type"] = "application/x-www-form-urlencoded";
+			fetchBody = body.toString();
+		} else fetchBody = body;
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: fetchBody,
+			credentials: "include"
+		});
+		if (response.status === 403 && retry) {
+			this.sid = null;
+			this.loggedIn = false;
+			return this.request(method, path, params, body, false);
+		}
+		if (!response.ok) throw new HTTPError(response.status, response.statusText);
+		const text = await response.text();
+		if (!text) return void 0;
+		try {
+			return JSON.parse(text);
+		} catch {
+			return text;
+		}
+	}
+	hashes(hashes) {
+		return hashes.join("|");
+	}
+	async info(params) {
+		const qs = {};
+		if (params) {
+			for (const [key, value] of Object.entries(params)) if (value !== void 0) qs[key] = String(value);
+		}
+		return this.get("/api/v2/torrents/info", qs);
+	}
+	async properties(hash) {
+		return this.get("/api/v2/torrents/properties", { hash });
+	}
+	async files(hash) {
+		return this.get("/api/v2/torrents/files", { hash });
+	}
+	async trackers(hash) {
+		return this.get("/api/v2/torrents/trackers", { hash });
+	}
+	async pieceStates(hash) {
+		return this.get("/api/v2/torrents/pieceStates", { hash });
+	}
+	async add(params) {
+		const form = new FormData();
+		for (const [key, value] of Object.entries(params)) {
+			if (value === void 0) continue;
+			if (key === "torrents") form.append("torrents", value, "torrent");
+			else form.append(key, String(value));
+		}
+		if (await this.post("/api/v2/torrents/add", form) === "Fails.") throw new QBittorrentError("Failed to add torrent");
+	}
+	async delete(hashes, deleteFiles = false) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("deleteFiles", String(deleteFiles));
+		await this.post("/api/v2/torrents/delete", body);
+	}
+	async start(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/start", body);
+	}
+	async stop(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/stop", body);
+	}
+	async recheck(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/recheck", body);
+	}
+	async reannounce(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/reannounce", body);
+	}
+	async setDownloadLimit(hashes, limit) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("limit", String(limit));
+		await this.post("/api/v2/torrents/setDownloadLimit", body);
+	}
+	async setUploadLimit(hashes, limit) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("limit", String(limit));
+		await this.post("/api/v2/torrents/setUploadLimit", body);
+	}
+	async setShareLimits(hashes, ratioLimit, seedingTimeLimit, inactiveSeedingTimeLimit) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("ratioLimit", String(ratioLimit));
+		body.set("seedingTimeLimit", String(seedingTimeLimit));
+		body.set("inactiveSeedingTimeLimit", String(inactiveSeedingTimeLimit));
+		await this.post("/api/v2/torrents/setShareLimits", body);
+	}
+	async setLocation(hashes, location) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("location", location);
+		await this.post("/api/v2/torrents/setLocation", body);
+	}
+	async rename(hash, name) {
+		const body = new URLSearchParams();
+		body.set("hash", hash);
+		body.set("name", name);
+		await this.post("/api/v2/torrents/rename", body);
+	}
+	async filePrio(hash, fileIds, priority) {
+		const body = new URLSearchParams();
+		body.set("hash", hash);
+		body.set("id", fileIds.join("|"));
+		body.set("priority", String(priority));
+		await this.post("/api/v2/torrents/filePrio", body);
+	}
+	async topPrio(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/topPrio", body);
+	}
+	async increasePrio(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/increasePrio", body);
+	}
+	async decreasePrio(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/decreasePrio", body);
+	}
+	async bottomPrio(hashes) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		await this.post("/api/v2/torrents/bottomPrio", body);
+	}
+	async setForceStart(hashes, value) {
+		const body = new URLSearchParams();
+		body.set("hashes", this.hashes(hashes));
+		body.set("value", String(value));
+		await this.post("/api/v2/torrents/setForceStart", body);
+	}
+	async torrentPeers(hash, rid) {
+		const params = { hash };
+		if (rid !== void 0) params.rid = String(rid);
+		return this.get("/api/v2/sync/torrentPeers", params);
+	}
+	async transferInfo() {
+		return this.get("/api/v2/transfer/info");
+	}
+	async speedLimitsMode() {
+		const result = await this.get("/api/v2/transfer/speedLimitsMode");
+		return Number(result);
+	}
+	async toggleSpeedLimitsMode() {
+		await this.post("/api/v2/transfer/toggleSpeedLimitsMode");
+	}
+	async setGlobalDownloadLimit(limit) {
+		const body = new URLSearchParams();
+		body.set("limit", String(limit));
+		await this.post("/api/v2/transfer/setDownloadLimit", body);
+	}
+	async setGlobalUploadLimit(limit) {
+		const body = new URLSearchParams();
+		body.set("limit", String(limit));
+		await this.post("/api/v2/transfer/setUploadLimit", body);
+	}
+	async version() {
+		return this.get("/api/v2/app/version");
+	}
+	async webapiVersion() {
+		return this.get("/api/v2/app/webapiVersion");
+	}
+	async preferences() {
+		return this.get("/api/v2/app/preferences");
+	}
+	async setPreferences(prefs) {
+		const body = new URLSearchParams();
+		body.set("json", JSON.stringify(prefs));
+		await this.post("/api/v2/app/setPreferences", body);
+	}
+	async defaultSavePath() {
+		return this.get("/api/v2/app/defaultSavePath");
+	}
+	async shutdown() {
+		await this.post("/api/v2/app/shutdown");
+	}
+};
+
+//#endregion
+export { HTTPError, QBittorrentError, QBittorrentClient as default };

package/dist/schemas.cjs

@@ -0,0 +1,287 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let zod = require("zod");
+
+//#region src/schemas.ts
+const QBittorrentConfigSchema = zod.z.object({
+	url: zod.z.string(),
+	username: zod.z.string().optional(),
+	password: zod.z.string().optional()
+});
+const TorrentStateSchema = zod.z.enum([
+	"error",
+	"missingFiles",
+	"uploading",
+	"stoppedUP",
+	"queuedUP",
+	"stalledUP",
+	"checkingUP",
+	"forcedUP",
+	"allocating",
+	"downloading",
+	"metaDL",
+	"forcedMetaDL",
+	"stoppedDL",
+	"queuedDL",
+	"stalledDL",
+	"checkingDL",
+	"forcedDL",
+	"checkingResumeData",
+	"moving",
+	"unknown"
+]);
+const TorrentInfoSchema = zod.z.object({
+	hash: zod.z.string(),
+	infohash_v1: zod.z.string(),
+	infohash_v2: zod.z.string(),
+	name: zod.z.string(),
+	magnet_uri: zod.z.string(),
+	size: zod.z.number(),
+	total_size: zod.z.number(),
+	progress: zod.z.number(),
+	dlspeed: zod.z.number(),
+	upspeed: zod.z.number(),
+	priority: zod.z.number(),
+	num_seeds: zod.z.number(),
+	num_complete: zod.z.number(),
+	num_leechs: zod.z.number(),
+	num_incomplete: zod.z.number(),
+	ratio: zod.z.number(),
+	eta: zod.z.number(),
+	state: TorrentStateSchema,
+	seq_dl: zod.z.boolean(),
+	f_l_piece_prio: zod.z.boolean(),
+	category: zod.z.string(),
+	tags: zod.z.string(),
+	super_seeding: zod.z.boolean(),
+	force_start: zod.z.boolean(),
+	save_path: zod.z.string(),
+	download_path: zod.z.string(),
+	content_path: zod.z.string(),
+	added_on: zod.z.number(),
+	completion_on: zod.z.number(),
+	tracker: zod.z.string(),
+	trackers_count: zod.z.number(),
+	dl_limit: zod.z.number(),
+	up_limit: zod.z.number(),
+	downloaded: zod.z.number(),
+	uploaded: zod.z.number(),
+	downloaded_session: zod.z.number(),
+	uploaded_session: zod.z.number(),
+	amount_left: zod.z.number(),
+	completed: zod.z.number(),
+	max_ratio: zod.z.number(),
+	max_seeding_time: zod.z.number(),
+	max_inactive_seeding_time: zod.z.number(),
+	ratio_limit: zod.z.number(),
+	seeding_time_limit: zod.z.number(),
+	inactive_seeding_time_limit: zod.z.number(),
+	seen_complete: zod.z.number(),
+	last_activity: zod.z.number(),
+	auto_tmm: zod.z.boolean(),
+	time_active: zod.z.number(),
+	seeding_time: zod.z.number(),
+	availability: zod.z.number(),
+	reannounce: zod.z.number(),
+	comment: zod.z.string(),
+	popularity: zod.z.number()
+}).passthrough();
+const TorrentInfoParamsSchema = zod.z.object({
+	filter: zod.z.enum([
+		"all",
+		"downloading",
+		"seeding",
+		"completed",
+		"stopped",
+		"active",
+		"inactive",
+		"running",
+		"stalled",
+		"stalled_uploading",
+		"stalled_downloading",
+		"errored"
+	]).optional(),
+	category: zod.z.string().optional(),
+	tag: zod.z.string().optional(),
+	sort: zod.z.string().optional(),
+	reverse: zod.z.boolean().optional(),
+	limit: zod.z.number().optional(),
+	offset: zod.z.number().optional(),
+	hashes: zod.z.string().optional()
+});
+const TorrentPropertiesSchema = zod.z.object({
+	addition_date: zod.z.number(),
+	comment: zod.z.string(),
+	completion_date: zod.z.number(),
+	created_by: zod.z.string(),
+	creation_date: zod.z.number(),
+	dl_limit: zod.z.number(),
+	dl_speed: zod.z.number(),
+	dl_speed_avg: zod.z.number(),
+	eta: zod.z.number(),
+	isPrivate: zod.z.boolean().optional(),
+	last_seen: zod.z.number(),
+	nb_connections: zod.z.number(),
+	nb_connections_limit: zod.z.number(),
+	peers: zod.z.number(),
+	peers_total: zod.z.number(),
+	piece_size: zod.z.number(),
+	pieces_have: zod.z.number(),
+	pieces_num: zod.z.number(),
+	reannounce: zod.z.number(),
+	save_path: zod.z.string(),
+	seeding_time: zod.z.number(),
+	seeds: zod.z.number(),
+	seeds_total: zod.z.number(),
+	share_ratio: zod.z.number(),
+	time_elapsed: zod.z.number(),
+	total_downloaded: zod.z.number(),
+	total_downloaded_session: zod.z.number(),
+	total_size: zod.z.number(),
+	total_uploaded: zod.z.number(),
+	total_uploaded_session: zod.z.number(),
+	total_wasted: zod.z.number(),
+	up_limit: zod.z.number(),
+	up_speed: zod.z.number(),
+	up_speed_avg: zod.z.number()
+}).passthrough();
+const TorrentFileSchema = zod.z.object({
+	index: zod.z.number(),
+	name: zod.z.string(),
+	size: zod.z.number(),
+	progress: zod.z.number(),
+	priority: zod.z.number(),
+	is_seed: zod.z.boolean(),
+	piece_range: zod.z.array(zod.z.number()),
+	availability: zod.z.number()
+}).passthrough();
+const TorrentTrackerSchema = zod.z.object({
+	url: zod.z.string(),
+	status: zod.z.number(),
+	tier: zod.z.number(),
+	num_peers: zod.z.number(),
+	num_seeds: zod.z.number(),
+	num_leeches: zod.z.number(),
+	num_downloaded: zod.z.number(),
+	msg: zod.z.string()
+}).passthrough();
+const TorrentPeerSchema = zod.z.object({
+	ip: zod.z.string(),
+	port: zod.z.number(),
+	client: zod.z.string(),
+	peer_id_client: zod.z.string(),
+	progress: zod.z.number(),
+	dl_speed: zod.z.number(),
+	up_speed: zod.z.number(),
+	downloaded: zod.z.number(),
+	uploaded: zod.z.number(),
+	connection: zod.z.string(),
+	flags: zod.z.string(),
+	flags_desc: zod.z.string(),
+	country: zod.z.string(),
+	country_code: zod.z.string(),
+	relevance: zod.z.number(),
+	files: zod.z.string()
+}).passthrough();
+const TorrentPeersResponseSchema = zod.z.object({
+	rid: zod.z.number(),
+	peers: zod.z.record(zod.z.string(), TorrentPeerSchema),
+	peers_removed: zod.z.array(zod.z.string()).optional(),
+	full_update: zod.z.boolean().optional()
+}).passthrough();
+const TransferInfoSchema = zod.z.object({
+	dl_info_speed: zod.z.number(),
+	dl_info_data: zod.z.number(),
+	up_info_speed: zod.z.number(),
+	up_info_data: zod.z.number(),
+	dl_rate_limit: zod.z.number(),
+	up_rate_limit: zod.z.number(),
+	dht_nodes: zod.z.number(),
+	connection_status: zod.z.string()
+}).passthrough();
+const PreferencesSchema = zod.z.object({
+	save_path: zod.z.string(),
+	temp_path_enabled: zod.z.boolean(),
+	temp_path: zod.z.string(),
+	start_paused_enabled: zod.z.boolean().optional(),
+	preallocate_all: zod.z.boolean(),
+	auto_tmm_enabled: zod.z.boolean(),
+	dl_limit: zod.z.number(),
+	up_limit: zod.z.number(),
+	alt_dl_limit: zod.z.number(),
+	alt_up_limit: zod.z.number(),
+	scheduler_enabled: zod.z.boolean(),
+	schedule_from_hour: zod.z.number(),
+	schedule_from_min: zod.z.number(),
+	schedule_to_hour: zod.z.number(),
+	schedule_to_min: zod.z.number(),
+	scheduler_days: zod.z.number(),
+	listen_port: zod.z.number(),
+	upnp: zod.z.boolean(),
+	random_port: zod.z.boolean(),
+	max_connec: zod.z.number(),
+	max_connec_per_torrent: zod.z.number(),
+	max_uploads: zod.z.number(),
+	max_uploads_per_torrent: zod.z.number(),
+	dht: zod.z.boolean(),
+	pex: zod.z.boolean(),
+	lsd: zod.z.boolean(),
+	encryption: zod.z.number(),
+	anonymous_mode: zod.z.boolean(),
+	max_ratio_enabled: zod.z.boolean(),
+	max_ratio: zod.z.number(),
+	max_ratio_act: zod.z.number(),
+	max_seeding_time_enabled: zod.z.boolean(),
+	max_seeding_time: zod.z.number(),
+	max_inactive_seeding_time_enabled: zod.z.boolean().optional(),
+	max_inactive_seeding_time: zod.z.number().optional(),
+	queueing_enabled: zod.z.boolean(),
+	max_active_downloads: zod.z.number(),
+	max_active_torrents: zod.z.number(),
+	max_active_uploads: zod.z.number(),
+	dont_count_slow_torrents: zod.z.boolean(),
+	slow_torrent_dl_rate_threshold: zod.z.number(),
+	slow_torrent_ul_rate_threshold: zod.z.number(),
+	slow_torrent_inactive_timer: zod.z.number(),
+	web_ui_port: zod.z.number()
+}).passthrough();
+const TorrentFileInputBlobSchema = zod.z.custom((value) => typeof Blob !== "undefined" && value instanceof Blob, "Expected Blob");
+const TorrentFileInputObjectSchema = zod.z.object({
+	uri: zod.z.string(),
+	type: zod.z.string(),
+	name: zod.z.string()
+});
+const TorrentFileInputSchema = zod.z.union([TorrentFileInputBlobSchema, TorrentFileInputObjectSchema]);
+const AddTorrentParamsSchema = zod.z.object({
+	urls: zod.z.string().optional(),
+	torrents: TorrentFileInputSchema.optional(),
+	savepath: zod.z.string().optional(),
+	cookie: zod.z.string().optional(),
+	category: zod.z.string().optional(),
+	tags: zod.z.string().optional(),
+	skip_checking: zod.z.boolean().optional(),
+	paused: zod.z.boolean().optional(),
+	root_folder: zod.z.boolean().optional(),
+	rename: zod.z.string().optional(),
+	upLimit: zod.z.number().optional(),
+	dlLimit: zod.z.number().optional(),
+	ratioLimit: zod.z.number().optional(),
+	seedingTimeLimit: zod.z.number().optional(),
+	autoTMM: zod.z.boolean().optional(),
+	sequentialDownload: zod.z.boolean().optional(),
+	firstLastPiecePrio: zod.z.boolean().optional()
+});
+
+//#endregion
+exports.AddTorrentParamsSchema = AddTorrentParamsSchema;
+exports.PreferencesSchema = PreferencesSchema;
+exports.QBittorrentConfigSchema = QBittorrentConfigSchema;
+exports.TorrentFileInputSchema = TorrentFileInputSchema;
+exports.TorrentFileSchema = TorrentFileSchema;
+exports.TorrentInfoParamsSchema = TorrentInfoParamsSchema;
+exports.TorrentInfoSchema = TorrentInfoSchema;
+exports.TorrentPeerSchema = TorrentPeerSchema;
+exports.TorrentPeersResponseSchema = TorrentPeersResponseSchema;
+exports.TorrentPropertiesSchema = TorrentPropertiesSchema;
+exports.TorrentStateSchema = TorrentStateSchema;
+exports.TorrentTrackerSchema = TorrentTrackerSchema;
+exports.TransferInfoSchema = TransferInfoSchema;