byr-pt-cli 0.1.0

package/dist/cli-CdpxYIyd.mjs

@@ -0,0 +1,794 @@
+import { renderDownloadOutput, runDownloadCommand } from "./commands/download.mjs";
+import { renderGetOutput, runGetCommand } from "./commands/get.mjs";
+import { renderSearchOutput, runSearchCommand } from "./commands/search.mjs";
+import { a as BYR_INCLDEAD_FACET, c as parseCategoryAliases, i as BYR_BOOKMARKED_FACET, l as parseSimpleFacetAliases, o as BYR_SPSTATE_FACET, s as getByrMetadata, t as createByrClient } from "./client-DT9oDCaE.mjs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { CliAppError, EXIT_CODES, createCommandContext, createErrorEnvelope, createSuccessEnvelope, mapErrorCodeToExitCode, toCliAppError } from "@onemoreproduct/cli-core";
+import { copyFileSync, existsSync, readFileSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createDecipheriv, pbkdf2Sync, randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+//#region src/domain/auth/browser.ts
+const TARGET_DOMAINS = new Set([
+	".byr.pt",
+	"byr.pt",
+	".bt.byr.cn",
+	"bt.byr.cn"
+]);
+async function importCookieFromBrowser(browser, profile) {
+	if (process.platform !== "darwin") throw new CliAppError({
+		code: "E_AUTH_REQUIRED",
+		message: `Browser cookie import is only supported on macOS (requested: ${browser})`
+	});
+	if (browser === "chrome") return importCookieFromChrome(profile);
+	return importCookieFromSafari();
+}
+function importCookieFromChrome(profile) {
+	const profilesRoot = join(process.env.HOME ?? "", "Library", "Application Support", "Google", "Chrome");
+	const profileName = profile?.trim().length ? profile.trim() : "Default";
+	const selectedDb = join(profilesRoot, profileName, "Cookies");
+	const fallbackDb = join(profilesRoot, "Default", "Cookies");
+	const dbPath = existsSync(selectedDb) ? selectedDb : fallbackDb;
+	if (!existsSync(dbPath)) throw new CliAppError({
+		code: "E_AUTH_REQUIRED",
+		message: "Chrome cookies database not found",
+		details: { checked: [selectedDb, fallbackDb] }
+	});
+	const tempDir = join(tmpdir(), `byr-cli-${randomUUID()}`);
+	const tempDb = join(tempDir, "Cookies");
+	spawnSync("mkdir", ["-p", tempDir], { stdio: "ignore" });
+	copyFileSync(dbPath, tempDb);
+	const wal = `${dbPath}-wal`;
+	const shm = `${dbPath}-shm`;
+	if (existsSync(wal)) copyFileSync(wal, `${tempDb}-wal`);
+	if (existsSync(shm)) copyFileSync(shm, `${tempDb}-shm`);
+	const sqlite = spawnSync("sqlite3", [
+		"-separator",
+		"	",
+		tempDb,
+		"SELECT name, value, hex(encrypted_value) FROM cookies WHERE host_key IN ('.byr.pt','byr.pt','.bt.byr.cn','bt.byr.cn') AND name IN ('uid','pass')"
+	], { encoding: "utf8" });
+	if (sqlite.status !== 0) throw new CliAppError({
+		code: "E_AUTH_REQUIRED",
+		message: "Failed to read Chrome cookies with sqlite3",
+		details: { stderr: sqlite.stderr?.trim() }
+	});
+	const decrypted = /* @__PURE__ */ new Map();
+	const lines = (sqlite.stdout ?? "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	let keyHex;
+	for (const line of lines) {
+		const [name, value, encryptedHex] = line.split("	");
+		if (name !== "uid" && name !== "pass") continue;
+		if (value && value.length > 0) {
+			decrypted.set(name, value);
+			continue;
+		}
+		if (!keyHex) keyHex = getChromeSafeStorageKeyHex();
+		if (!encryptedHex || encryptedHex.length === 0 || !keyHex) continue;
+		const resolved = decryptChromeCookieHex(encryptedHex, keyHex);
+		if (resolved) decrypted.set(name, resolved);
+	}
+	const uid = decrypted.get("uid");
+	const pass = decrypted.get("pass");
+	if (!uid || !pass) throw new CliAppError({
+		code: "E_AUTH_REQUIRED",
+		message: "Unable to extract uid/pass from Chrome cookies",
+		details: { profile: profileName }
+	});
+	return {
+		cookie: `uid=${uid}; pass=${pass}`,
+		source: `chrome:${profileName}`
+	};
+}
+function getChromeSafeStorageKeyHex() {
+	for (const [service, account] of [["Chrome Safe Storage", "Chrome"], ["Chrome Safe Storage", "Google Chrome"]]) {
+		const command = spawnSync("security", [
+			"find-generic-password",
+			"-w",
+			"-s",
+			service,
+			"-a",
+			account
+		], { encoding: "utf8" });
+		if (command.status !== 0) continue;
+		const password = command.stdout.trim();
+		if (password.length === 0) continue;
+		return pbkdf2Sync(password, "saltysalt", 1003, 16, "sha1").toString("hex");
+	}
+}
+function decryptChromeCookieHex(encryptedHex, keyHex) {
+	try {
+		let encrypted = Buffer.from(encryptedHex, "hex");
+		if (encrypted.length === 0) return;
+		if (encrypted.subarray(0, 3).toString("utf8") === "v10") encrypted = encrypted.subarray(3);
+		const decipher = createDecipheriv("aes-128-cbc", Buffer.from(keyHex, "hex"), Buffer.alloc(16, 32));
+		return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8").replaceAll("\0", "").trim();
+	} catch {
+		return;
+	}
+}
+function importCookieFromSafari() {
+	const home = process.env.HOME ?? "";
+	const sqliteCandidates = [join(home, "Library", "Cookies", "Cookies.sqlite"), join(home, "Library", "Containers", "com.apple.Safari", "Data", "Library", "Cookies", "Cookies.sqlite")];
+	for (const sqlitePath of sqliteCandidates) {
+		if (!existsSync(sqlitePath)) continue;
+		const result = tryReadSafariSqlite(sqlitePath);
+		if (result) return result;
+	}
+	const binaryCandidates = [join(home, "Library", "Cookies", "Cookies.binarycookies"), join(home, "Library", "Containers", "com.apple.Safari", "Data", "Library", "Cookies", "Cookies.binarycookies")];
+	for (const binaryPath of binaryCandidates) {
+		if (!existsSync(binaryPath)) continue;
+		const result = tryReadSafariBinaryCookies(binaryPath);
+		if (result) return result;
+	}
+	throw new CliAppError({
+		code: "E_AUTH_REQUIRED",
+		message: "Safari cookie import failed (best effort)",
+		details: {
+			hint: "Use `byr auth import-cookie --cookie \"uid=...; pass=...\"` as fallback.",
+			checked: [...sqliteCandidates, ...binaryCandidates]
+		}
+	});
+}
+function tryReadSafariSqlite(path) {
+	const sqlite = spawnSync("sqlite3", [
+		"-separator",
+		"	",
+		path,
+		"SELECT name, value, host FROM cookies WHERE host IN ('.byr.pt','byr.pt','.bt.byr.cn','bt.byr.cn') AND name IN ('uid','pass')"
+	], { encoding: "utf8" });
+	if (sqlite.status !== 0) return;
+	const records = [];
+	for (const line of (sqlite.stdout ?? "").split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		const [name, value, domain] = trimmed.split("	");
+		if (!name || !value || !domain) continue;
+		records.push({
+			name,
+			value,
+			domain
+		});
+	}
+	return extractByrCookie(records, `safari-sqlite:${path}`);
+}
+function tryReadSafariBinaryCookies(path) {
+	let buffer;
+	try {
+		if (statSync(path).size <= 0) return;
+		buffer = readFileSync(path);
+	} catch {
+		return;
+	}
+	return extractByrCookie(parseBinaryCookies(buffer), `safari-binarycookies:${path}`);
+}
+function extractByrCookie(records, source) {
+	const map = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (!TARGET_DOMAINS.has(record.domain)) continue;
+		if (record.name === "uid" || record.name === "pass") map.set(record.name, record.value);
+	}
+	const uid = map.get("uid");
+	const pass = map.get("pass");
+	if (!uid || !pass) return;
+	return {
+		cookie: `uid=${uid}; pass=${pass}`,
+		source
+	};
+}
+function parseBinaryCookies(buffer) {
+	if (buffer.length < 8 || buffer.subarray(0, 4).toString("ascii") !== "cook") return [];
+	const numPages = buffer.readUInt32BE(4);
+	const pageSizes = [];
+	let cursor = 8;
+	for (let index = 0; index < numPages; index += 1) {
+		if (cursor + 4 > buffer.length) return [];
+		pageSizes.push(buffer.readUInt32BE(cursor));
+		cursor += 4;
+	}
+	const records = [];
+	let pageOffset = cursor;
+	for (const pageSize of pageSizes) {
+		if (pageOffset + pageSize > buffer.length) break;
+		const page = buffer.subarray(pageOffset, pageOffset + pageSize);
+		records.push(...parseBinaryCookiePage(page));
+		pageOffset += pageSize;
+	}
+	return records;
+}
+function parseBinaryCookiePage(page) {
+	if (page.length < 8) return [];
+	const count = page.readUInt32LE(4);
+	const records = [];
+	let offsetTable = 8;
+	for (let index = 0; index < count; index += 1) {
+		if (offsetTable + 4 > page.length) break;
+		const cookieOffset = page.readUInt32LE(offsetTable);
+		offsetTable += 4;
+		const parsed = parseBinaryCookie(page, cookieOffset);
+		if (parsed !== void 0) records.push(parsed);
+	}
+	return records;
+}
+function parseBinaryCookie(page, cookieOffset) {
+	if (cookieOffset + 40 > page.length) return;
+	const size = page.readUInt32LE(cookieOffset);
+	if (size <= 0 || cookieOffset + size > page.length) return;
+	const slice = page.subarray(cookieOffset, cookieOffset + size);
+	const domainOffset = slice.readUInt32LE(16);
+	const nameOffset = slice.readUInt32LE(20);
+	const valueOffset = slice.readUInt32LE(28);
+	const domain = readCString(slice, domainOffset);
+	const name = readCString(slice, nameOffset);
+	const value = readCString(slice, valueOffset);
+	if (!domain || !name || !value) return;
+	return {
+		domain,
+		name,
+		value
+	};
+}
+function readCString(buffer, offset) {
+	if (offset <= 0 || offset >= buffer.length) return "";
+	let end = offset;
+	while (end < buffer.length && buffer[end] !== 0) end += 1;
+	return buffer.subarray(offset, end).toString("utf8").trim();
+}
+
+//#endregion
+//#region src/domain/auth/store.ts
+function getByrConfigDir() {
+	return join(homedir(), ".config", "byr-cli");
+}
+function getByrGlobalConfigPath() {
+	return join(getByrConfigDir(), "config.json");
+}
+function getByrAuthStorePath() {
+	return join(getByrConfigDir(), "auth.json");
+}
+async function readJsonFile(path) {
+	try {
+		const content = await readFile(path, "utf8");
+		return JSON.parse(content);
+	} catch (error) {
+		const nodeError = error;
+		if (nodeError.code === "ENOENT") return;
+		throw new CliAppError({
+			code: "E_AUTH_INVALID",
+			message: `Failed to read JSON file: ${path}`,
+			details: {
+				path,
+				reason: nodeError.message
+			},
+			cause: error
+		});
+	}
+}
+async function writeJsonFile(path, data) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+async function readAuthStore() {
+	const store = await readJsonFile(getByrAuthStorePath());
+	if (store === void 0) return;
+	if (typeof store.cookie !== "string" || typeof store.source !== "string" || typeof store.updatedAt !== "string") return;
+	return {
+		cookie: store.cookie,
+		source: store.source,
+		updatedAt: store.updatedAt
+	};
+}
+async function writeAuthStore(cookie, source) {
+	const store = {
+		cookie,
+		source,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeJsonFile(getByrAuthStorePath(), store);
+	return store;
+}
+async function clearAuthStore() {
+	try {
+		await rm(getByrAuthStorePath(), { force: true });
+		return true;
+	} catch (error) {
+		throw new CliAppError({
+			code: "E_AUTH_INVALID",
+			message: "Failed to clear BYR auth store",
+			details: { reason: error.message },
+			cause: error
+		});
+	}
+}
+function parseCookieHeader(cookieHeader) {
+	const cookieMap = /* @__PURE__ */ new Map();
+	for (const part of cookieHeader.split(";")) {
+		const segment = part.trim();
+		if (segment.length === 0) continue;
+		const eqIndex = segment.indexOf("=");
+		if (eqIndex <= 0) continue;
+		const name = segment.slice(0, eqIndex).trim();
+		const value = segment.slice(eqIndex + 1).trim();
+		if (name.length > 0) cookieMap.set(name, value);
+	}
+	return {
+		uid: cookieMap.get("uid"),
+		pass: cookieMap.get("pass"),
+		sessionId: cookieMap.get("session_id"),
+		authToken: cookieMap.get("auth_token"),
+		refreshToken: cookieMap.get("refresh_token"),
+		cookieMap
+	};
+}
+function validateByrCookie(cookieHeader) {
+	const parsed = parseCookieHeader(cookieHeader);
+	const hasLegacyCookie = Boolean(parsed.uid && parsed.pass);
+	const hasSessionCookie = Boolean(parsed.sessionId && parsed.authToken);
+	if (!hasLegacyCookie && !hasSessionCookie) throw new CliAppError({
+		code: "E_AUTH_INVALID",
+		message: "BYR cookie must include uid/pass or session_id/auth_token",
+		details: { requiredAnyOf: [["uid", "pass"], ["session_id", "auth_token"]] }
+	});
+	return parsed;
+}
+function maskCookieValue(value, visible = 4) {
+	if (value.length <= visible) return "*".repeat(value.length);
+	return `${value.slice(0, visible)}${"*".repeat(Math.max(4, value.length - visible))}`;
+}
+function maskCookieHeader(cookieHeader) {
+	const parsed = parseCookieHeader(cookieHeader);
+	return Array.from(parsed.cookieMap.entries()).map(([name, value]) => name === "uid" || name === "pass" ? `${name}=${maskCookieValue(value)}` : `${name}=***`).join("; ");
+}
+
+//#endregion
+//#region src/domain/auth/config.ts
+function firstString(value) {
+	if (value === void 0) return;
+	if (Array.isArray(value)) {
+		const candidate = value.at(-1);
+		return typeof candidate === "string" ? candidate : void 0;
+	}
+	return typeof value === "string" ? value : void 0;
+}
+function toValidTimeout(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	if (typeof value === "string") {
+		const parsed = Number.parseInt(value, 10);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+}
+function nonEmpty(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function getProjectConfigPath(cwd) {
+	return join(cwd, ".byrrc.json");
+}
+async function resolveClientConfig(input) {
+	const env = input.env ?? process.env;
+	const projectConfig = await readJsonFile(getProjectConfigPath(input.cwd)) ?? {};
+	const globalConfig = await readJsonFile(getByrGlobalConfigPath()) ?? {};
+	const authStore = await readAuthStore();
+	const cookieFromFlag = nonEmpty(firstString(input.getFlag("cookie")));
+	const usernameFromFlag = nonEmpty(firstString(input.getFlag("username")));
+	const passwordFromFlag = nonEmpty(firstString(input.getFlag("password")));
+	const baseUrlFromFlag = nonEmpty(firstString(input.getFlag("base-url")));
+	const timeoutFromFlag = toValidTimeout(firstString(input.getFlag("timeout-ms")));
+	const cookieFromEnv = nonEmpty(env.BYR_COOKIE);
+	const usernameFromEnv = nonEmpty(env.BYR_USERNAME);
+	const passwordFromEnv = nonEmpty(env.BYR_PASSWORD);
+	const baseUrlFromEnv = nonEmpty(env.BYR_BASE_URL);
+	const timeoutFromEnv = toValidTimeout(env.BYR_TIMEOUT_MS);
+	const cookieFromProject = nonEmpty(projectConfig.cookie);
+	const usernameFromProject = nonEmpty(projectConfig.username);
+	const passwordFromProject = nonEmpty(projectConfig.password);
+	const baseUrlFromProject = nonEmpty(projectConfig.baseUrl);
+	const timeoutFromProject = toValidTimeout(projectConfig.timeoutMs);
+	const cookieFromGlobal = nonEmpty(globalConfig.cookie);
+	const usernameFromGlobal = nonEmpty(globalConfig.username);
+	const passwordFromGlobal = nonEmpty(globalConfig.password);
+	const baseUrlFromGlobal = nonEmpty(globalConfig.baseUrl);
+	const timeoutFromGlobal = toValidTimeout(globalConfig.timeoutMs);
+	const cookieFromStore = nonEmpty(authStore?.cookie);
+	const cookie = cookieFromFlag ?? cookieFromEnv ?? cookieFromProject ?? cookieFromGlobal ?? cookieFromStore;
+	const cookieSource = cookie === void 0 ? void 0 : cookie === cookieFromFlag ? "flag" : cookie === cookieFromEnv ? "env" : cookie === cookieFromProject ? "project-config" : cookie === cookieFromGlobal ? "global-config" : authStore?.source ?? "auth-store";
+	return {
+		cookie,
+		username: usernameFromFlag ?? usernameFromEnv ?? usernameFromProject ?? usernameFromGlobal,
+		password: passwordFromFlag ?? passwordFromEnv ?? passwordFromProject ?? passwordFromGlobal,
+		baseUrl: baseUrlFromFlag ?? baseUrlFromEnv ?? baseUrlFromProject ?? baseUrlFromGlobal,
+		timeoutMs: timeoutFromFlag ?? timeoutFromEnv ?? timeoutFromProject ?? timeoutFromGlobal,
+		cookieSource
+	};
+}
+
+//#endregion
+//#region src/cli.ts
+async function runCli(argv, deps = {}) {
+	const stdout = deps.stdout ?? process.stdout;
+	const stderr = deps.stderr ?? process.stderr;
+	const parsed = parseArgs(argv);
+	const json = getBooleanFlag(parsed.flags, "json");
+	const verbose = getBooleanFlag(parsed.flags, "verbose");
+	const context = createCommandContext({
+		clock: deps.clock,
+		now: deps.now,
+		requestIdFactory: deps.requestIdFactory,
+		verbose
+	});
+	if (parsed.command === void 0 || parsed.command === "help") {
+		stdout.write(`${renderHelp()}\n`);
+		return EXIT_CODES.SUCCESS;
+	}
+	let resolvedClient;
+	const getClient = async () => {
+		if (deps.client) return deps.client;
+		if (resolvedClient) return resolvedClient;
+		const resolved = await resolveClientConfig({
+			cwd: process.cwd(),
+			env: process.env,
+			getFlag: (key) => parsed.flags.get(key)
+		});
+		resolvedClient = createByrClient({
+			baseUrl: resolved.baseUrl,
+			timeoutMs: resolved.timeoutMs,
+			cookie: resolved.cookie,
+			username: resolved.username,
+			password: resolved.password
+		});
+		return resolvedClient;
+	};
+	try {
+		const result = await dispatch(parsed, {
+			getClient,
+			fileWriter: deps.fileWriter ?? writeFile
+		});
+		if (json) stdout.write(`${JSON.stringify(createSuccessEnvelope(result.data, context.toMeta()))}\n`);
+		else stdout.write(`${result.humanOutput}\n`);
+		return EXIT_CODES.SUCCESS;
+	} catch (error) {
+		const appError = toCliAppError(error);
+		const exitCode = mapErrorCodeToExitCode(appError.code);
+		if (json) stdout.write(`${JSON.stringify(createErrorEnvelope(appError.code, appError.message, appError.details))}\n`);
+		else stderr.write(formatHumanError(appError));
+		return exitCode;
+	}
+}
+async function dispatch(parsed, deps) {
+	switch (parsed.command) {
+		case "search": return dispatchSearch(parsed, deps);
+		case "get": return dispatchGet(parsed, deps);
+		case "download": return dispatchDownload(parsed, deps);
+		case "user": return dispatchUser(parsed, deps);
+		case "meta": return dispatchMeta(parsed, deps);
+		case "auth": return dispatchAuth(parsed, deps);
+		default: throw createArgumentError("E_ARG_UNSUPPORTED", `Unknown command: ${parsed.command}`, { command: parsed.command });
+	}
+}
+async function dispatchSearch(parsed, deps) {
+	const query = getOptionalString(parsed.flags, "query") ?? "";
+	const imdb = getOptionalString(parsed.flags, "imdb");
+	const limit = getPositiveInteger(parsed.flags, "limit", 10);
+	if (query.trim().length === 0 && (imdb === void 0 || imdb.trim().length === 0)) throw createArgumentError("E_ARG_MISSING", "--query or --imdb is required", { arg: "query|imdb" });
+	if (query.trim().length > 0 && imdb !== void 0) throw createArgumentError("E_ARG_CONFLICT", "--query and --imdb cannot be used together", { args: ["query", "imdb"] });
+	const categoryParsed = parseCategoryAliases(getStringValues(parsed.flags, "category"));
+	if (categoryParsed.invalid.length > 0) throw createArgumentError("E_ARG_INVALID", "--category contains invalid values", {
+		invalid: categoryParsed.invalid,
+		allowed: getByrMetadata().category.options.map((option) => option.aliases).flat()
+	});
+	const incldead = parseSingleFacetFlag(parsed.flags, "incldead", BYR_INCLDEAD_FACET);
+	const spstate = parseSingleFacetFlag(parsed.flags, "spstate", BYR_SPSTATE_FACET);
+	const bookmarked = parseSingleFacetFlag(parsed.flags, "bookmarked", BYR_BOOKMARKED_FACET);
+	const page = getOptionalPositiveInteger(parsed.flags, "page");
+	const options = {
+		categoryIds: categoryParsed.values.length > 0 ? categoryParsed.values : void 0,
+		incldead,
+		spstate,
+		bookmarked,
+		imdb,
+		page
+	};
+	const output = await runSearchCommand(await deps.getClient(), {
+		query,
+		limit,
+		options
+	});
+	return {
+		data: output,
+		humanOutput: renderSearchOutput(output)
+	};
+}
+async function dispatchGet(parsed, deps) {
+	const id = getRequiredString(parsed.flags, "id");
+	const output = await runGetCommand(await deps.getClient(), { id });
+	return {
+		data: output,
+		humanOutput: renderGetOutput(output)
+	};
+}
+async function dispatchDownload(parsed, deps) {
+	const id = getRequiredString(parsed.flags, "id");
+	const outputPath = getRequiredString(parsed.flags, "output");
+	const dryRun = getBooleanFlag(parsed.flags, "dry-run");
+	const output = await runDownloadCommand(await deps.getClient(), {
+		id,
+		outputPath,
+		dryRun,
+		writeFile: deps.fileWriter
+	});
+	return {
+		data: output,
+		humanOutput: renderDownloadOutput(output)
+	};
+}
+async function dispatchUser(parsed, deps) {
+	const subcommand = parsed.positional[0];
+	if (subcommand !== "info") throw createArgumentError("E_ARG_UNSUPPORTED", "user subcommand must be: info", { subcommand });
+	const client = await deps.getClient();
+	if (typeof client.getUserInfo !== "function") throw createArgumentError("E_ARG_UNSUPPORTED", "Current client does not support user info", {});
+	const info = await client.getUserInfo();
+	return {
+		data: info,
+		humanOutput: [
+			`User: ${info.name} (${info.id})`,
+			`Level: ${info.levelName}${info.levelId ? ` (#${info.levelId})` : ""}`,
+			`Ratio: ${info.ratio}`,
+			`Uploaded/Downloaded: ${info.trueUploadedBytes}/${info.trueDownloadedBytes}`,
+			`Messages: ${info.messageCount}`,
+			`Bonus/h: ${info.bonusPerHour}`,
+			`Seeding: ${info.seeding} (${info.seedingSizeBytes} bytes)`,
+			`Uploads: ${info.uploads}`,
+			`Last access: ${info.lastAccessAt}`
+		].join("\n")
+	};
+}
+async function dispatchMeta(parsed, deps) {
+	const subcommand = parsed.positional[0];
+	const client = await deps.getClient();
+	if (subcommand === "categories") {
+		const categories = typeof client.getCategories === "function" ? await client.getCategories() : getByrMetadata();
+		return {
+			data: categories,
+			humanOutput: ["BYR categories:", ...categories.category.options.map((item) => `  ${item.value}: ${item.name}`)].join("\n")
+		};
+	}
+	if (subcommand === "levels") {
+		const levels = typeof client.getLevelRequirements === "function" ? await client.getLevelRequirements() : getByrMetadata().levels;
+		return {
+			data: levels,
+			humanOutput: ["BYR levels:", ...levels.map((level) => `  #${level.id} ${level.name}`)].join("\n")
+		};
+	}
+	throw createArgumentError("E_ARG_UNSUPPORTED", "meta subcommand must be: categories|levels", { subcommand });
+}
+async function dispatchAuth(parsed, deps) {
+	const subcommand = parsed.positional[0];
+	switch (subcommand) {
+		case "status": {
+			const verify = getBooleanFlag(parsed.flags, "verify");
+			const resolved = await resolveClientConfig({
+				cwd: process.cwd(),
+				env: process.env,
+				getFlag: (key) => parsed.flags.get(key)
+			});
+			const hasCredentials = typeof resolved.cookie === "string" && resolved.cookie.trim().length > 0;
+			const result = {
+				hasCredentials,
+				source: resolved.cookieSource ?? "none",
+				cookie: hasCredentials ? maskCookieHeader(resolved.cookie) : void 0
+			};
+			if (verify && hasCredentials) {
+				const verifier = (await deps.getClient()).verifyAuth;
+				if (typeof verifier === "function") result.verify = await verifier();
+				else result.verify = { authenticated: false };
+			}
+			return {
+				data: result,
+				humanOutput: [
+					`Credentials: ${hasCredentials ? "present" : "missing"}`,
+					`Source: ${String(result.source)}`,
+					verify ? `Verified: ${String(result.verify?.authenticated ?? false)}` : void 0
+				].filter((line) => Boolean(line)).join("\n")
+			};
+		}
+		case "import-cookie": {
+			const manualCookie = getOptionalString(parsed.flags, "cookie");
+			const fromBrowser = getOptionalString(parsed.flags, "from-browser");
+			const profile = getOptionalString(parsed.flags, "profile");
+			if (manualCookie && fromBrowser || !manualCookie && !fromBrowser) throw createArgumentError("E_ARG_CONFLICT", "Use either --cookie or --from-browser", { args: ["cookie", "from-browser"] });
+			let cookieToStore;
+			let source;
+			if (manualCookie) {
+				validateByrCookie(manualCookie);
+				cookieToStore = manualCookie;
+				source = "manual";
+			} else {
+				if (fromBrowser !== "chrome" && fromBrowser !== "safari") throw createArgumentError("E_ARG_INVALID", "--from-browser must be chrome|safari", { value: fromBrowser });
+				const imported = await importCookieFromBrowser(fromBrowser, profile);
+				validateByrCookie(imported.cookie);
+				cookieToStore = imported.cookie;
+				source = imported.source;
+			}
+			const saved = await writeAuthStore(cookieToStore, source);
+			return {
+				data: {
+					source: saved.source,
+					updatedAt: saved.updatedAt,
+					cookie: maskCookieHeader(saved.cookie)
+				},
+				humanOutput: [
+					"BYR cookie imported.",
+					`Source: ${saved.source}`,
+					`Updated: ${saved.updatedAt}`
+				].join("\n")
+			};
+		}
+		case "logout": {
+			const deleted = await clearAuthStore();
+			return {
+				data: { deleted },
+				humanOutput: deleted ? "BYR auth store cleared." : "BYR auth store was already empty."
+			};
+		}
+		default: throw createArgumentError("E_ARG_UNSUPPORTED", "auth subcommand must be: status|import-cookie|logout", { subcommand });
+	}
+}
+function parseArgs(argv) {
+	const command = argv[0];
+	const flags = /* @__PURE__ */ new Map();
+	const positional = [];
+	for (let index = 1; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (!token.startsWith("--")) {
+			positional.push(token);
+			continue;
+		}
+		const stripped = token.slice(2);
+		const eqIndex = stripped.indexOf("=");
+		if (eqIndex >= 0) {
+			appendFlagValue(flags, stripped.slice(0, eqIndex), stripped.slice(eqIndex + 1));
+			continue;
+		}
+		const next = argv[index + 1];
+		if (next !== void 0 && !next.startsWith("--")) {
+			appendFlagValue(flags, stripped, next);
+			index += 1;
+			continue;
+		}
+		flags.set(stripped, true);
+	}
+	return {
+		command,
+		flags,
+		positional
+	};
+}
+function appendFlagValue(flags, key, value) {
+	const previous = flags.get(key);
+	if (previous === void 0) {
+		flags.set(key, value);
+		return;
+	}
+	if (Array.isArray(previous)) {
+		flags.set(key, [...previous, value]);
+		return;
+	}
+	if (typeof previous === "string") {
+		flags.set(key, [previous, value]);
+		return;
+	}
+	flags.set(key, value);
+}
+function getBooleanFlag(flags, key) {
+	const value = flags.get(key);
+	if (value === void 0) return false;
+	if (typeof value === "boolean") return value;
+	if (Array.isArray(value)) {
+		const candidate = value.at(-1);
+		if (candidate === "true") return true;
+		if (candidate === "false") return false;
+		throw createArgumentError("E_ARG_INVALID", `--${key} must be true or false`, {
+			arg: key,
+			value: candidate
+		});
+	}
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw createArgumentError("E_ARG_INVALID", `--${key} must be true or false`, {
+		arg: key,
+		value
+	});
+}
+function getRequiredString(flags, key) {
+	const value = getOptionalString(flags, key);
+	if (value === void 0 || value.trim().length === 0) throw createArgumentError("E_ARG_MISSING", `--${key} is required`, { arg: key });
+	return value;
+}
+function getOptionalString(flags, key) {
+	const value = flags.get(key);
+	if (value === void 0 || typeof value === "boolean") return;
+	if (Array.isArray(value)) {
+		const candidate = value.at(-1);
+		return candidate !== void 0 && candidate.trim().length > 0 ? candidate : void 0;
+	}
+	return value.trim().length > 0 ? value : void 0;
+}
+function getStringValues(flags, key) {
+	const value = flags.get(key);
+	if (value === void 0 || typeof value === "boolean") return [];
+	return (Array.isArray(value) ? value : [value]).filter((item) => item.trim().length > 0);
+}
+function getPositiveInteger(flags, key, fallback) {
+	const value = getOptionalString(flags, key);
+	if (value === void 0) return fallback;
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw createArgumentError("E_ARG_INVALID", `--${key} must be a positive integer`, {
+		arg: key,
+		value
+	});
+	return parsed;
+}
+function getOptionalPositiveInteger(flags, key) {
+	const value = getOptionalString(flags, key);
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw createArgumentError("E_ARG_INVALID", `--${key} must be a positive integer`, {
+		arg: key,
+		value
+	});
+	return parsed;
+}
+function parseSingleFacetFlag(flags, key, facet) {
+	const values = getStringValues(flags, key);
+	if (values.length === 0) return;
+	const parsed = parseSimpleFacetAliases(facet, values);
+	if (parsed.invalid.length > 0) throw createArgumentError("E_ARG_INVALID", `--${key} contains invalid values`, {
+		invalid: parsed.invalid,
+		allowed: facet.options.map((option) => option.aliases).flat()
+	});
+	if (parsed.values.length !== 1) throw createArgumentError("E_ARG_INVALID", `--${key} expects exactly one value`, { values });
+	return parsed.values[0];
+}
+function renderHelp() {
+	return [
+		"byr CLI",
+		"",
+		"Usage:",
+		"  byr search --query <text> [--limit <n>] [--category <alias|id>] [--incldead <alias|id>] [--spstate <alias|id>] [--bookmarked <alias|id>] [--page <n>] [--json]",
+		"  byr search --imdb <tt-id> [--limit <n>] [--json]",
+		"  byr get --id <torrent-id> [--json]",
+		"  byr download --id <torrent-id> --output <path> [--dry-run] [--json]",
+		"  byr user info [--json]",
+		"  byr meta categories [--json]",
+		"  byr meta levels [--json]",
+		"  byr auth status [--verify] [--json]",
+		"  byr auth import-cookie --cookie \"uid=...; pass=...\" [--json]",
+		"  byr auth import-cookie --from-browser <chrome|safari> [--profile <name>] [--json]",
+		"  byr auth logout [--json]",
+		"",
+		"Auth priority:",
+		"  CLI flags > ENV > ./.byrrc.json > ~/.config/byr-cli/config.json > ~/.config/byr-cli/auth.json",
+		"",
+		"Flags:",
+		"  --json       Output CliEnvelope JSON",
+		"  --dry-run    Validate and show write plan without writing files",
+		"  --verbose    Include verbose mode in metadata"
+	].join("\n");
+}
+function createArgumentError(code, message, details) {
+	return new CliAppError({
+		code,
+		message,
+		details
+	});
+}
+function formatHumanError(error) {
+	const details = error.details === void 0 ? "" : `\nDetails: ${JSON.stringify(error.details)}`;
+	return `Error (${error.code}): ${error.message}${details}\n`;
+}
+
+//#endregion
+export { runCli as t };