@zfadhli/tokrec 0.2.1

package/dist/api/client.mjs

@@ -0,0 +1,40 @@
+import { createSession } from "wreq-js";
+//#region src/api/client.ts
+/**
+* HTTP client — thin wrapper around wreq-js createSession.
+* Provides TLS fingerprint impersonation, cookie jar, and proxy support.
+*/
+async function createHttpClient(config) {
+	const session = await createSession({
+		browser: "chrome_142",
+		os: "windows",
+		proxy: config.proxy
+	});
+	if (config.cookies?.sessionid_ss) {
+		session.setCookie("sessionid_ss", config.cookies.sessionid_ss, "https://www.tiktok.com");
+		if (config.cookies["tt-target-idc"]) session.setCookie("tt-target-idc", config.cookies["tt-target-idc"], "https://www.tiktok.com");
+	}
+	return {
+		get: async (url) => {
+			return await session.fetch(url, { signal: AbortSignal.timeout(15e3) });
+		},
+		post: async (url, body, headers) => {
+			return await session.fetch(url, {
+				method: "POST",
+				body,
+				signal: AbortSignal.timeout(15e3),
+				headers: {
+					"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+					...headers
+				}
+			});
+		},
+		close: async () => {
+			await session.close();
+		}
+	};
+}
+//#endregion
+export { createHttpClient };
+
+//# sourceMappingURL=client.mjs.map

package/dist/api/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../../src/api/client.ts"],"sourcesContent":["/**\n * HTTP client — thin wrapper around wreq-js createSession.\n * Provides TLS fingerprint impersonation, cookie jar, and proxy support.\n */\n\nimport { type Session, createSession } from 'wreq-js'\nimport type { RecorderConfig } from '../config'\n\nexport interface HttpClient {\n  get: (url: string) => Promise<Response>\n  post: (url: string, body?: BodyInit, headers?: Record<string, string>) => Promise<Response>\n  close: () => Promise<void>\n}\n\nexport async function createHttpClient(config: RecorderConfig): Promise<HttpClient> {\n  const session: Session = await createSession({\n    browser: 'chrome_142',\n    os: 'windows',\n    proxy: config.proxy,\n  } as any)\n\n  // Seed cookies into the session jar so all subsequent requests are authenticated.\n  // NOTE: Using a Cookie header does NOT populate wreq-js's cookie jar —\n  // we must use session.setCookie() instead.\n  if (config.cookies?.sessionid_ss) {\n    session.setCookie('sessionid_ss', config.cookies.sessionid_ss, 'https://www.tiktok.com')\n    if (config.cookies['tt-target-idc']) {\n      session.setCookie('tt-target-idc', config.cookies['tt-target-idc'], 'https://www.tiktok.com')\n    }\n  }\n\n  return {\n    get: async (url: string) => {\n      const res = await session.fetch(url, { signal: AbortSignal.timeout(15000) } as any)\n      return res as unknown as Response\n    },\n    post: async (url: string, body?: BodyInit, headers?: Record<string, string>) => {\n      const res = await session.fetch(url, {\n        method: 'POST',\n        body,\n        signal: AbortSignal.timeout(15000),\n        headers: {\n          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',\n          ...headers,\n        },\n      } as any)\n      return res as unknown as Response\n    },\n    close: async () => {\n      await session.close()\n    },\n  }\n}\n"],"mappings":";;;;;;AAcA,eAAsB,iBAAiB,QAA6C;CAClF,MAAM,UAAmB,MAAM,cAAc;EAC3C,SAAS;EACT,IAAI;EACJ,OAAO,OAAO;CAChB,CAAQ;CAKR,IAAI,OAAO,SAAS,cAAc;EAChC,QAAQ,UAAU,gBAAgB,OAAO,QAAQ,cAAc,wBAAwB;EACvF,IAAI,OAAO,QAAQ,kBACjB,QAAQ,UAAU,iBAAiB,OAAO,QAAQ,kBAAkB,wBAAwB;CAEhG;CAEA,OAAO;EACL,KAAK,OAAO,QAAgB;GAE1B,OAAO,MADW,QAAQ,MAAM,KAAK,EAAE,QAAQ,YAAY,QAAQ,IAAK,EAAE,CAAQ;EAEpF;EACA,MAAM,OAAO,KAAa,MAAiB,YAAqC;GAU9E,OAAO,MATW,QAAQ,MAAM,KAAK;IACnC,QAAQ;IACR;IACA,QAAQ,YAAY,QAAQ,IAAK;IACjC,SAAS;KACP,gBAAgB;KAChB,GAAG;IACL;GACF,CAAQ;EAEV;EACA,OAAO,YAAY;GACjB,MAAM,QAAQ,MAAM;EACtB;CACF;AACF"}

package/dist/api/tiktok.mjs

@@ -0,0 +1,144 @@
+//#region src/api/tiktok.ts
+const TIKTOK_BASE = "https://www.tiktok.com";
+const WEBCAST_BASE = "https://webcast.tiktok.com";
+function createTikTokApi(http) {
+	let cached = null;
+	let cachedUser = "";
+	async function ensureCache(user) {
+		if (cached && cachedUser === user) return cached;
+		cached = await fetchLiveInfo(user);
+		cachedUser = user;
+		return cached;
+	}
+	function invalidateCache() {
+		cached = null;
+		cachedUser = "";
+	}
+	return {
+		invalidateCache,
+		async getRoomId(user) {
+			return (await ensureCache(user))?.roomId ?? null;
+		},
+		async isRoomAlive(roomId) {
+			if (cached && String(cached.roomId) === String(roomId)) return cached.isLive;
+			return (await fetchLiveInfo(cachedUser || roomId))?.isLive ?? false;
+		},
+		async getLiveUrl(roomId) {
+			return (await ensureCache(cachedUser || roomId))?.streamUrl ?? null;
+		}
+	};
+	async function fetchLiveInfo(user) {
+		try {
+			const res = await http.get(`${TIKTOK_BASE}/@${user}/live`);
+			if (!res.ok) return null;
+			const sigi = extractSigiState(await res.text());
+			if (!sigi) return null;
+			const liveRoom = sigi.LiveRoom?.liveRoomUserInfo?.liveRoom;
+			const userInfo = sigi.LiveRoom?.liveRoomUserInfo?.user;
+			if (!liveRoom || !userInfo?.roomId) return null;
+			const roomId = String(userInfo.roomId);
+			const isLive = liveRoom.status === 2;
+			let streamUrl = null;
+			if (isLive) {
+				streamUrl = extractStreamUrlFast(liveRoom);
+				if (!streamUrl) streamUrl = findStreamUrlRecursively(sigi);
+				if (!streamUrl) streamUrl = await fetchStreamUrlFromApi(roomId);
+			}
+			return {
+				roomId,
+				isLive,
+				streamUrl,
+				title: liveRoom.title ?? null
+			};
+		} catch (_err) {
+			return null;
+		}
+	}
+	/**
+	* Fallback: fetch stream URL from the Webcast API.
+	* This covers cases where SIGI_STATE doesn't include stream data
+	* (e.g. async-loaded room info).
+	*/
+	async function fetchStreamUrlFromApi(roomId) {
+		try {
+			const url = `${WEBCAST_BASE}/webcast/room/info/?aid=1988&room_id=${roomId}&type=live`;
+			const res = await http.get(url);
+			if (!res.ok) return null;
+			const text = await res.text();
+			if (text.length === 0) return null;
+			const data = JSON.parse(text);
+			if (data.status_code === 4003110) return null;
+			return findStreamUrlRecursively(data);
+		} catch {
+			return null;
+		}
+	}
+}
+function extractSigiState(html) {
+	const match = html.match(/<script\s+id="SIGI_STATE"\s+type="application\/json">(.*?)<\/script>/);
+	if (!match?.[1]) return null;
+	try {
+		return JSON.parse(match[1]);
+	} catch {
+		return null;
+	}
+}
+/**
+* Fast-path: extract stream URL from the known SIGI_STATE location.
+* This covers ~95% of cases without needing a full recursive search.
+*/
+function extractStreamUrlFast(liveRoom) {
+	try {
+		const raw = liveRoom?.streamData?.pull_data?.stream_data;
+		if (!raw) return null;
+		const data = JSON.parse(raw)?.data;
+		if (!data) return null;
+		for (const q of [
+			"origin",
+			"fhd",
+			"uhd",
+			"hd",
+			"sd",
+			"ld"
+		]) {
+			const url = data[q]?.main?.flv;
+			if (url) return url;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Brute-force recursive search for a stream URL anywhere in a JSON value.
+* Survives TikTok changing key names or nesting structure.
+*
+* Inspired by PR #430 (Michele0303/tiktok-live-recorder).
+*/
+function findStreamUrlRecursively(obj) {
+	if (typeof obj === "string") {
+		if ((obj.startsWith("http://") || obj.startsWith("https://")) && (obj.includes(".flv") || obj.includes(".m3u8"))) return obj;
+		if (obj.startsWith("{") || obj.startsWith("[")) try {
+			return findStreamUrlRecursively(JSON.parse(obj));
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+		for (const val of Object.values(obj)) {
+			const found = findStreamUrlRecursively(val);
+			if (found) return found;
+		}
+		return null;
+	}
+	if (Array.isArray(obj)) for (const item of obj) {
+		const found = findStreamUrlRecursively(item);
+		if (found) return found;
+	}
+	return null;
+}
+//#endregion
+export { createTikTokApi };
+
+//# sourceMappingURL=tiktok.mjs.map

package/dist/api/tiktok.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiktok.mjs","names":[],"sources":["../../src/api/tiktok.ts"],"sourcesContent":["/**\n * TikTok API — resolves room IDs, live status, and stream URLs from a single\n * SIGI_STATE HTML scrape. No webcast API calls needed.\n *\n * Architecture:\n *   createTikTokApi(httpClient) → { getRoomId, isRoomAlive, getLiveUrl }\n *\n * All public methods share a per-tick cache so the page is fetched at most once\n * per poll cycle.\n */\n\nimport type { HttpClient } from './client'\n\nexport interface TikTokApi {\n  /** Resolve a username to a room ID. Returns null if not found. */\n  getRoomId(user: string): Promise<string | null>\n  /** Check if a room is currently live. */\n  isRoomAlive(roomId: string): Promise<boolean>\n  /** Get the best-quality FLV stream URL for a room. Returns null on failure. */\n  getLiveUrl(roomId: string): Promise<string | null>\n  /** Invalidate per-tick cache (call at start of each poll tick). */\n  invalidateCache(): void\n}\n\nconst TIKTOK_BASE = 'https://www.tiktok.com'\nconst WEBCAST_BASE = 'https://webcast.tiktok.com'\n\nexport function createTikTokApi(http: HttpClient): TikTokApi {\n  // Per-tick cache — stores the last fetched live info so the three public\n  // methods don't each fetch the page separately.\n  let cached: LiveInfo | null = null\n  let cachedUser = ''\n\n  async function ensureCache(user: string): Promise<LiveInfo | null> {\n    if (cached && cachedUser === user) return cached\n    cached = await fetchLiveInfo(user)\n    cachedUser = user\n    return cached\n  }\n\n  function invalidateCache(): void {\n    cached = null\n    cachedUser = ''\n  }\n\n  return {\n    invalidateCache,\n\n    async getRoomId(user: string): Promise<string | null> {\n      const info = await ensureCache(user)\n      return info?.roomId ?? null\n    },\n\n    async isRoomAlive(roomId: string): Promise<boolean> {\n      if (cached && String(cached.roomId) === String(roomId)) {\n        return cached.isLive\n      }\n      const info = await fetchLiveInfo(cachedUser || roomId)\n      return info?.isLive ?? false\n    },\n\n    async getLiveUrl(roomId: string): Promise<string | null> {\n      const info = await ensureCache(cachedUser || roomId)\n      return info?.streamUrl ?? null\n    },\n  }\n\n  // ─── Internal: fetch and parse SIGI_STATE ─────────────────\n\n  async function fetchLiveInfo(user: string): Promise<LiveInfo | null> {\n    try {\n      const res = await http.get(`${TIKTOK_BASE}/@${user}/live`)\n      if (!res.ok) return null\n\n      const html = await res.text()\n      const sigi = extractSigiState(html)\n      if (!sigi) return null\n\n      const liveRoom = sigi.LiveRoom?.liveRoomUserInfo?.liveRoom\n      const userInfo = sigi.LiveRoom?.liveRoomUserInfo?.user\n\n      if (!liveRoom || !userInfo?.roomId) return null\n\n      const roomId = String(userInfo.roomId)\n      const isLive = liveRoom.status === 2 // 2 = live, 4 = offline\n\n      // Extract stream URL: try SIGI_STATE first, then Webcast API fallback\n      let streamUrl: string | null = null\n      if (isLive) {\n        streamUrl = extractStreamUrlFast(liveRoom)\n        if (!streamUrl) {\n          streamUrl = findStreamUrlRecursively(sigi)\n        }\n        if (!streamUrl) {\n          streamUrl = await fetchStreamUrlFromApi(roomId)\n        }\n      }\n\n      return { roomId, isLive, streamUrl, title: liveRoom.title ?? null }\n    } catch (_err) {\n      // Timeout (15s) or network error → treat as offline\n      return null\n    }\n  }\n\n  /**\n   * Fallback: fetch stream URL from the Webcast API.\n   * This covers cases where SIGI_STATE doesn't include stream data\n   * (e.g. async-loaded room info).\n   */\n  async function fetchStreamUrlFromApi(roomId: string): Promise<string | null> {\n    try {\n      const url = `${WEBCAST_BASE}/webcast/room/info/?aid=1988&room_id=${roomId}&type=live`\n      const res = await http.get(url)\n      if (!res.ok) return null\n\n      const text = await res.text()\n      if (text.length === 0) return null\n\n      const data = JSON.parse(text) as Record<string, unknown>\n\n      // status_code 4003110 = live restriction / room not found\n      if ((data as any).status_code === 4003110) return null\n\n      return findStreamUrlRecursively(data)\n    } catch {\n      return null\n    }\n  }\n}\n\n// ─── Types ──────────────────────────────────────────────────\n\ninterface LiveInfo {\n  roomId: string\n  isLive: boolean\n  streamUrl: string | null\n  title: string | null\n}\n\ninterface SigiState {\n  LiveRoom?: {\n    liveRoomStatus?: number\n    liveRoomUserInfo?: {\n      user?: {\n        roomId?: string | number\n      }\n      liveRoom?: {\n        status?: number // 2 = live, 4 = offline\n        title?: string\n        startTime?: number\n        streamData?: {\n          pull_data?: {\n            stream_data?: string // JSON string with FLV/HLS URLs\n          }\n        }\n      }\n    }\n  }\n}\n\n// ─── HTML parsing ──────────────────────────────────────────\n\nfunction extractSigiState(html: string): SigiState | null {\n  const match = html.match(/<script\\s+id=\"SIGI_STATE\"\\s+type=\"application\\/json\">(.*?)<\\/script>/)\n  if (!match?.[1]) return null\n  try {\n    return JSON.parse(match[1]) as SigiState\n  } catch {\n    return null\n  }\n}\n\n// ─── Stream URL extraction ─────────────────────────────────\n\n/**\n * Fast-path: extract stream URL from the known SIGI_STATE location.\n * This covers ~95% of cases without needing a full recursive search.\n */\nfunction extractStreamUrlFast(\n  liveRoom: NonNullable<NonNullable<SigiState['LiveRoom']>['liveRoomUserInfo']>['liveRoom'],\n): string | null {\n  try {\n    const raw = liveRoom?.streamData?.pull_data?.stream_data\n    if (!raw) return null\n    const parsed = JSON.parse(raw) as Record<string, unknown>\n    const data = (parsed as Record<string, unknown>)?.data as Record<string, unknown> | undefined\n    if (!data) return null\n\n    // Try all known quality keys, preferring higher quality\n    const qualities = ['origin', 'fhd', 'uhd', 'hd', 'sd', 'ld']\n    for (const q of qualities) {\n      const entry = data[q] as { main?: { flv?: string } } | undefined\n      const url = entry?.main?.flv\n      if (url) return url\n    }\n    return null\n  } catch {\n    return null\n  }\n}\n\n/**\n * Brute-force recursive search for a stream URL anywhere in a JSON value.\n * Survives TikTok changing key names or nesting structure.\n *\n * Inspired by PR #430 (Michele0303/tiktok-live-recorder).\n */\nexport function findStreamUrlRecursively(obj: unknown): string | null {\n  // Base case: a string\n  if (typeof obj === 'string') {\n    // Direct URL match\n    if (\n      (obj.startsWith('http://') || obj.startsWith('https://')) &&\n      (obj.includes('.flv') || obj.includes('.m3u8'))\n    ) {\n      return obj\n    }\n    // JSON-encoded string — parse and recurse (covers stream_data, etc.)\n    if (obj.startsWith('{') || obj.startsWith('[')) {\n      try {\n        return findStreamUrlRecursively(JSON.parse(obj))\n      } catch {\n        return null\n      }\n    }\n    return null\n  }\n\n  // Dict: recurse into all values\n  if (obj && typeof obj === 'object' && !Array.isArray(obj)) {\n    for (const val of Object.values(obj as Record<string, unknown>)) {\n      const found = findStreamUrlRecursively(val)\n      if (found) return found\n    }\n    return null\n  }\n\n  // Array: recurse into all elements\n  if (Array.isArray(obj)) {\n    for (const item of obj) {\n      const found = findStreamUrlRecursively(item)\n      if (found) return found\n    }\n  }\n\n  return null\n}\n"],"mappings":"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"}

package/dist/cli.mjs

@@ -0,0 +1,69 @@
+import { TikTokError } from "./config.mjs";
+import { sanitizeUser } from "./utils.mjs";
+import { createCLI } from "@zfadhli/koko-cli";
+//#region src/cli.ts
+/**
+* CLI argument parser — uses koko-cli's createCLI (wraps cac).
+* Exports a single parseArgs() function.
+*/
+function parseArgs(argv = process.argv) {
+	let config;
+	let error;
+	const cli = createCLI("tiktok-live-recorder", "0.2.1").description("Minimal TikTok live stream recorder — Bun + TypeScript");
+	cli.command("", "Record a TikTok live stream", (cmd) => {
+		cmd.option("-u, --user <name>", "TikTok username (required)");
+		cmd.option("-o, --output <dir>", "Output directory", { default: "./recordings" });
+		cmd.option("-i, --interval <minutes>", "Polling interval in minutes", { default: "3" });
+		cmd.option("-d, --duration <minutes>", "Max recording duration in minutes");
+		cmd.option("-p, --proxy <url>", "HTTP proxy (e.g. http://127.0.0.1:8080)");
+		cmd.option("-l, --log-level <level>", "Log level: debug | info | warn | error");
+		cmd.option("-c, --cookies <path>", "Path to cookies.json");
+		cmd.option("-s, --segment-minutes <minutes>", "Segment duration in minutes", { default: "20" });
+		cmd.action((opts) => {
+			try {
+				const user = opts.user;
+				if (!user) throw new TikTokError("config-error", "--user is required");
+				const parsed = { user: sanitizeUser(user) };
+				if (opts.output) parsed.outputDir = opts.output;
+				if (opts.interval !== void 0) {
+					const n = Number(opts.interval);
+					if (!Number.isFinite(n) || n < 1) throw new TikTokError("config-error", "--interval must be a number >= 1");
+					parsed.interval = n;
+				}
+				if (opts.duration !== void 0) {
+					const n = Number(opts.duration);
+					if (!Number.isFinite(n) || n < 0) throw new TikTokError("config-error", "--duration must be a number >= 0 (minutes)");
+					parsed.duration = n * 60;
+				}
+				if (opts.proxy) parsed.proxy = opts.proxy;
+				if (opts.logLevel) {
+					const levels = [
+						"debug",
+						"info",
+						"warn",
+						"error"
+					];
+					if (!levels.includes(opts.logLevel)) throw new TikTokError("config-error", `--log-level must be one of: ${levels.join(", ")}`);
+					parsed.logLevel = opts.logLevel;
+				}
+				if (opts.cookies) parsed.cookiesPath = opts.cookies;
+				if (opts.segmentMinutes !== void 0) {
+					const n = Number(opts.segmentMinutes);
+					if (!Number.isFinite(n) || n < 1) throw new TikTokError("config-error", "--segment-minutes must be a number >= 1");
+					parsed.segmentMinutes = n;
+				}
+				config = parsed;
+			} catch (err) {
+				error = err instanceof Error ? err.message : String(err);
+			}
+		});
+	});
+	cli.parse(argv);
+	if (error) throw new TikTokError("config-error", error);
+	if (!config) throw new TikTokError("config-error", "--user is required. Use --help for usage.");
+	return config;
+}
+//#endregion
+export { parseArgs };
+
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../src/cli.ts"],"sourcesContent":["/**\n * CLI argument parser — uses koko-cli's createCLI (wraps cac).\n * Exports a single parseArgs() function.\n */\n\nimport { createCLI } from '@zfadhli/koko-cli'\nimport type { LogLevel, RecorderConfig } from './config'\nimport { TikTokError } from './config'\nimport { sanitizeUser } from './utils'\n\nexport function parseArgs(argv: string[] = process.argv): RecorderConfig {\n  let config: RecorderConfig | undefined\n  let error: string | undefined\n\n  const cli = createCLI('tiktok-live-recorder', '0.2.1').description(\n    'Minimal TikTok live stream recorder — Bun + TypeScript',\n  )\n\n  cli.command('', 'Record a TikTok live stream', (cmd) => {\n    cmd.option('-u, --user <name>', 'TikTok username (required)')\n    cmd.option('-o, --output <dir>', 'Output directory', { default: './recordings' })\n    cmd.option('-i, --interval <minutes>', 'Polling interval in minutes', { default: '3' })\n    cmd.option('-d, --duration <minutes>', 'Max recording duration in minutes')\n    cmd.option('-p, --proxy <url>', 'HTTP proxy (e.g. http://127.0.0.1:8080)')\n    cmd.option('-l, --log-level <level>', 'Log level: debug | info | warn | error')\n    cmd.option('-c, --cookies <path>', 'Path to cookies.json')\n    cmd.option('-s, --segment-minutes <minutes>', 'Segment duration in minutes', { default: '20' })\n\n    cmd.action((opts: Record<string, unknown>) => {\n      try {\n        const user = opts.user as string | undefined\n        if (!user) {\n          throw new TikTokError('config-error', '--user is required')\n        }\n\n        const parsed: RecorderConfig = {\n          user: sanitizeUser(user),\n        }\n\n        if (opts.output) parsed.outputDir = opts.output as string\n        if (opts.interval !== undefined) {\n          const n = Number(opts.interval)\n          if (!Number.isFinite(n) || n < 1) {\n            throw new TikTokError('config-error', '--interval must be a number >= 1')\n          }\n          parsed.interval = n\n        }\n        if (opts.duration !== undefined) {\n          const n = Number(opts.duration)\n          if (!Number.isFinite(n) || n < 0) {\n            throw new TikTokError('config-error', '--duration must be a number >= 0 (minutes)')\n          }\n          parsed.duration = n * 60\n        }\n        if (opts.proxy) parsed.proxy = opts.proxy as string\n        if (opts.logLevel) {\n          const levels = ['debug', 'info', 'warn', 'error']\n          if (!levels.includes(opts.logLevel as string)) {\n            throw new TikTokError(\n              'config-error',\n              `--log-level must be one of: ${levels.join(', ')}`,\n            )\n          }\n          parsed.logLevel = opts.logLevel as LogLevel\n        }\n        if (opts.cookies) parsed.cookiesPath = opts.cookies as string\n        if (opts.segmentMinutes !== undefined) {\n          const n = Number(opts.segmentMinutes)\n          if (!Number.isFinite(n) || n < 1) {\n            throw new TikTokError('config-error', '--segment-minutes must be a number >= 1')\n          }\n          parsed.segmentMinutes = n\n        }\n\n        config = parsed\n      } catch (err) {\n        error = err instanceof Error ? err.message : String(err)\n      }\n    })\n  })\n\n  cli.parse(argv)\n\n  if (error) {\n    throw new TikTokError('config-error', error)\n  }\n\n  if (!config) {\n    throw new TikTokError('config-error', '--user is required. Use --help for usage.')\n  }\n\n  return config\n}\n"],"mappings":";;;;;;;;AAUA,SAAgB,UAAU,OAAiB,QAAQ,MAAsB;CACvE,IAAI;CACJ,IAAI;CAEJ,MAAM,MAAM,UAAU,wBAAwB,OAAO,CAAC,CAAC,YACrD,wDACF;CAEA,IAAI,QAAQ,IAAI,gCAAgC,QAAQ;EACtD,IAAI,OAAO,qBAAqB,4BAA4B;EAC5D,IAAI,OAAO,sBAAsB,oBAAoB,EAAE,SAAS,eAAe,CAAC;EAChF,IAAI,OAAO,4BAA4B,+BAA+B,EAAE,SAAS,IAAI,CAAC;EACtF,IAAI,OAAO,4BAA4B,mCAAmC;EAC1E,IAAI,OAAO,qBAAqB,yCAAyC;EACzE,IAAI,OAAO,2BAA2B,wCAAwC;EAC9E,IAAI,OAAO,wBAAwB,sBAAsB;EACzD,IAAI,OAAO,mCAAmC,+BAA+B,EAAE,SAAS,KAAK,CAAC;EAE9F,IAAI,QAAQ,SAAkC;GAC5C,IAAI;IACF,MAAM,OAAO,KAAK;IAClB,IAAI,CAAC,MACH,MAAM,IAAI,YAAY,gBAAgB,oBAAoB;IAG5D,MAAM,SAAyB,EAC7B,MAAM,aAAa,IAAI,EACzB;IAEA,IAAI,KAAK,QAAQ,OAAO,YAAY,KAAK;IACzC,IAAI,KAAK,aAAa,KAAA,GAAW;KAC/B,MAAM,IAAI,OAAO,KAAK,QAAQ;KAC9B,IAAI,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,GAC7B,MAAM,IAAI,YAAY,gBAAgB,kCAAkC;KAE1E,OAAO,WAAW;IACpB;IACA,IAAI,KAAK,aAAa,KAAA,GAAW;KAC/B,MAAM,IAAI,OAAO,KAAK,QAAQ;KAC9B,IAAI,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,GAC7B,MAAM,IAAI,YAAY,gBAAgB,4CAA4C;KAEpF,OAAO,WAAW,IAAI;IACxB;IACA,IAAI,KAAK,OAAO,OAAO,QAAQ,KAAK;IACpC,IAAI,KAAK,UAAU;KACjB,MAAM,SAAS;MAAC;MAAS;MAAQ;MAAQ;KAAO;KAChD,IAAI,CAAC,OAAO,SAAS,KAAK,QAAkB,GAC1C,MAAM,IAAI,YACR,gBACA,+BAA+B,OAAO,KAAK,IAAI,GACjD;KAEF,OAAO,WAAW,KAAK;IACzB;IACA,IAAI,KAAK,SAAS,OAAO,cAAc,KAAK;IAC5C,IAAI,KAAK,mBAAmB,KAAA,GAAW;KACrC,MAAM,IAAI,OAAO,KAAK,cAAc;KACpC,IAAI,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,GAC7B,MAAM,IAAI,YAAY,gBAAgB,yCAAyC;KAEjF,OAAO,iBAAiB;IAC1B;IAEA,SAAS;GACX,SAAS,KAAK;IACZ,QAAQ,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;GACzD;EACF,CAAC;CACH,CAAC;CAED,IAAI,MAAM,IAAI;CAEd,IAAI,OACF,MAAM,IAAI,YAAY,gBAAgB,KAAK;CAG7C,IAAI,CAAC,QACH,MAAM,IAAI,YAAY,gBAAgB,2CAA2C;CAGnF,OAAO;AACT"}

package/dist/config.d.mts

@@ -0,0 +1,104 @@
+//#region src/config.d.ts
+/**
+ * Config — types, defaults, and normalization for the recorder.
+ * The single source of truth for every user-facing option.
+ */
+interface CookieAuth {
+  sessionid_ss: string;
+  'tt-target-idc'?: string;
+}
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface RecorderConfig {
+  /** TikTok username (required) */
+  user: string;
+  /** Output directory for recordings (default: ./recordings) */
+  outputDir?: string;
+  /** Polling interval in minutes (default: 3) */
+  interval?: number;
+  /** Max recording duration in seconds (default: 0 — unlimited). CLI accepts minutes, converted internally. */
+  duration?: number;
+  /** HTTP proxy URL (e.g. http://127.0.0.1:8080) */
+  proxy?: string;
+  /** Path to cookies.json (default: ./cookies.json) */
+  cookiesPath?: string;
+  /** Cookie auth loaded from cookies.json */
+  cookies?: CookieAuth;
+  /** Log level (default: info) */
+  logLevel?: LogLevel;
+  /** Whether to print logs to console (default: true). Set false when using Display-based UI. */
+  logConsole?: boolean;
+  /** Segment duration in minutes (default: 20). Stream is cut into segments of this length. */
+  segmentMinutes?: number;
+}
+interface RecorderController {
+  /** Start the polling loop */
+  start(): Promise<void>;
+  /** Gracefully stop (joins active recording, then exits) */
+  stop(): Promise<void>;
+  /** Snapshot of current state */
+  getStatus(): RecorderStatus;
+  /** Subscribe to events */
+  on<E extends keyof RecorderEventHandler>(event: E, handler: RecorderEventHandler[E]): void;
+}
+interface RecorderStatus {
+  state: 'idle' | 'polling' | 'recording' | 'converting' | 'stopped';
+  user: string;
+  currentFile?: string;
+  sessionDuration?: number;
+  lastPollTime?: string;
+  lastError?: string;
+}
+type RecorderEvent = keyof RecorderEventHandler;
+interface RecorderEventHandler {
+  checking: (info: {
+    user: string;
+  }) => void;
+  tick: (info: {
+    user: string;
+    isLive: boolean;
+    roomId?: string;
+  }) => void;
+  'recording:start': (info: {
+    user: string;
+    file: string;
+  }) => void;
+  'download:progress': (info: {
+    bytes: number;
+    elapsed: number;
+    speed: number;
+  }) => void;
+  'download:end': (info: {
+    file: string;
+    duration: number;
+    size: number;
+  }) => void;
+  'recording:end': (info: {
+    file: string;
+    duration: number;
+    size: number;
+  }) => void;
+  'segmenting:start': (info: {
+    input: string;
+    outputPattern: string;
+  }) => void;
+  'segmenting:end': (info: {
+    segments: number;
+  }) => void;
+  'converting:start': (info: {
+    input: string;
+  }) => void;
+  converted: (info: {
+    input: string;
+    output: string;
+  }) => void;
+  error: (err: TikTokError) => void;
+}
+type AppErrorKind = 'user-not-live' | 'room-not-found' | 'stream-url-not-found' | 'waf-blocked' | 'country-blocked' | 'network-error' | 'ffmpeg-not-found' | 'config-error' | 'unknown';
+declare class TikTokError extends Error {
+  readonly kind: AppErrorKind;
+  readonly cause?: unknown | undefined;
+  constructor(kind: AppErrorKind, message: string, cause?: unknown | undefined);
+}
+//#endregion
+export { AppErrorKind, RecorderConfig, RecorderController, RecorderEvent, RecorderEventHandler, RecorderStatus, TikTokError };
+//# sourceMappingURL=config.d.mts.map

package/dist/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":";;AAKA;;;UAAiB,UAAA;EACf,YAAA;EACA,eAAe;AAAA;AAAA,KAGL,QAAA;AAAA,UAEK,cAAA;EAFG;EAIlB,IAAA;EAF6B;EAI7B,SAAA;EAYmB;EAVnB,QAAA;EAFA;EAIA,QAAA;EAAA;EAEA,KAAA;EAEA;EAAA,WAAA;EAEU;EAAV,OAAA,GAAU,UAAA;EAEC;EAAX,QAAA,GAAW,QAAQ;EAInB;EAFA,UAAA;EAEc;EAAd,cAAA;AAAA;AAAA,UAGe,kBAAA;EAEN;EAAT,KAAA,IAAS,OAAA;EAII;EAFb,IAAA,IAAQ,OAAA;EAIwC;EAFhD,SAAA,IAAa,cAAA;EAEoE;EAAjF,EAAA,iBAAmB,oBAAA,EAAsB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,oBAAA,CAAqB,CAAA;AAAA;AAAA,UAGlE,cAAA;EACf,KAAA;EACA,IAAA;EACA,WAAA;EACA,eAAA;EACA,YAAA;EACA,SAAA;AAAA;AAAA,KAGU,aAAA,SAAsB,oBAAoB;AAAA,UAErC,oBAAA;EACf,QAAA,GAAW,IAAA;IAAQ,IAAA;EAAA;EACnB,IAAA,GAAO,IAAA;IAAQ,IAAA;IAAc,MAAA;IAAiB,MAAA;EAAA;EAC9C,iBAAA,GAAoB,IAAA;IAAQ,IAAA;IAAc,IAAA;EAAA;EAC1C,mBAAA,GAAsB,IAAA;IAAQ,KAAA;IAAe,OAAA;IAAiB,KAAA;EAAA;EAC9D,cAAA,GAAiB,IAAA;IAAQ,IAAA;IAAc,QAAA;IAAkB,IAAA;EAAA;EACzD,eAAA,GAAkB,IAAA;IAAQ,IAAA;IAAc,QAAA;IAAkB,IAAA;EAAA;EAC1D,kBAAA,GAAqB,IAAA;IAAQ,KAAA;IAAe,aAAA;EAAA;EAC5C,gBAAA,GAAmB,IAAA;IAAQ,QAAA;EAAA;EAC3B,kBAAA,GAAqB,IAAA;IAAQ,KAAA;EAAA;EAC7B,SAAA,GAAY,IAAA;IAAQ,KAAA;IAAe,MAAA;EAAA;EACnC,KAAA,GAAQ,GAAA,EAAK,WAAW;AAAA;AAAA,KAGd,YAAA;AAAA,cAWC,WAAA,SAAoB,KAAA;EAAA,SAEb,IAAA,EAAM,YAAA;EAAA,SAEN,KAAA;cAFA,IAAA,EAAM,YAAA,EACtB,OAAA,UACgB,KAAA;AAAA"}

package/dist/config.mjs

@@ -0,0 +1,42 @@
+//#region src/config.ts
+var TikTokError = class extends Error {
+	kind;
+	cause;
+	constructor(kind, message, cause) {
+		super(message);
+		this.kind = kind;
+		this.cause = cause;
+		this.name = "TikTokError";
+	}
+};
+const DEFAULTS = {
+	outputDir: "./recordings",
+	interval: 3,
+	duration: 0,
+	logLevel: "info",
+	logConsole: true,
+	segmentMinutes: 20
+};
+function normalizeConfig(config) {
+	return {
+		user: config.user,
+		outputDir: config.outputDir ?? DEFAULTS.outputDir,
+		interval: config.interval ?? DEFAULTS.interval,
+		duration: config.duration ?? DEFAULTS.duration,
+		logLevel: config.logLevel ?? DEFAULTS.logLevel,
+		logConsole: config.logConsole ?? DEFAULTS.logConsole,
+		proxy: config.proxy,
+		cookies: config.cookies,
+		cookiesPath: config.cookiesPath,
+		segmentMinutes: config.segmentMinutes ?? DEFAULTS.segmentMinutes
+	};
+}
+function validateConfig(config) {
+	if (!config.user || config.user.trim().length === 0) throw new TikTokError("config-error", "--user is required");
+	if (config.interval !== void 0 && config.interval < 1) throw new TikTokError("config-error", "--interval must be >= 1 minute");
+	if (config.duration !== void 0 && config.duration < 0) throw new TikTokError("config-error", "--duration must be >= 0 seconds");
+}
+//#endregion
+export { TikTokError, normalizeConfig, validateConfig };
+
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../src/config.ts"],"sourcesContent":["/**\n * Config — types, defaults, and normalization for the recorder.\n * The single source of truth for every user-facing option.\n */\n\nexport interface CookieAuth {\n  sessionid_ss: string\n  'tt-target-idc'?: string\n}\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error'\n\nexport interface RecorderConfig {\n  /** TikTok username (required) */\n  user: string\n  /** Output directory for recordings (default: ./recordings) */\n  outputDir?: string\n  /** Polling interval in minutes (default: 3) */\n  interval?: number\n  /** Max recording duration in seconds (default: 0 — unlimited). CLI accepts minutes, converted internally. */\n  duration?: number\n  /** HTTP proxy URL (e.g. http://127.0.0.1:8080) */\n  proxy?: string\n  /** Path to cookies.json (default: ./cookies.json) */\n  cookiesPath?: string\n  /** Cookie auth loaded from cookies.json */\n  cookies?: CookieAuth\n  /** Log level (default: info) */\n  logLevel?: LogLevel\n  /** Whether to print logs to console (default: true). Set false when using Display-based UI. */\n  logConsole?: boolean\n  /** Segment duration in minutes (default: 20). Stream is cut into segments of this length. */\n  segmentMinutes?: number\n}\n\nexport interface RecorderController {\n  /** Start the polling loop */\n  start(): Promise<void>\n  /** Gracefully stop (joins active recording, then exits) */\n  stop(): Promise<void>\n  /** Snapshot of current state */\n  getStatus(): RecorderStatus\n  /** Subscribe to events */\n  on<E extends keyof RecorderEventHandler>(event: E, handler: RecorderEventHandler[E]): void\n}\n\nexport interface RecorderStatus {\n  state: 'idle' | 'polling' | 'recording' | 'converting' | 'stopped'\n  user: string\n  currentFile?: string\n  sessionDuration?: number\n  lastPollTime?: string\n  lastError?: string\n}\n\nexport type RecorderEvent = keyof RecorderEventHandler\n\nexport interface RecorderEventHandler {\n  checking: (info: { user: string }) => void\n  tick: (info: { user: string; isLive: boolean; roomId?: string }) => void\n  'recording:start': (info: { user: string; file: string }) => void\n  'download:progress': (info: { bytes: number; elapsed: number; speed: number }) => void\n  'download:end': (info: { file: string; duration: number; size: number }) => void\n  'recording:end': (info: { file: string; duration: number; size: number }) => void\n  'segmenting:start': (info: { input: string; outputPattern: string }) => void\n  'segmenting:end': (info: { segments: number }) => void\n  'converting:start': (info: { input: string }) => void\n  converted: (info: { input: string; output: string }) => void\n  error: (err: TikTokError) => void\n}\n\nexport type AppErrorKind =\n  | 'user-not-live'\n  | 'room-not-found'\n  | 'stream-url-not-found'\n  | 'waf-blocked'\n  | 'country-blocked'\n  | 'network-error'\n  | 'ffmpeg-not-found'\n  | 'config-error'\n  | 'unknown'\n\nexport class TikTokError extends Error {\n  constructor(\n    public readonly kind: AppErrorKind,\n    message: string,\n    public readonly cause?: unknown,\n  ) {\n    super(message)\n    this.name = 'TikTokError'\n  }\n}\n\nconst DEFAULTS = {\n  outputDir: './recordings',\n  interval: 3,\n  duration: 0,\n  logLevel: 'info' as LogLevel,\n  logConsole: true,\n  segmentMinutes: 20,\n}\n\nexport function normalizeConfig(\n  config: RecorderConfig,\n): Required<Omit<RecorderConfig, 'cookies' | 'cookiesPath' | 'proxy'>> &\n  Pick<RecorderConfig, 'cookies' | 'cookiesPath' | 'proxy'> {\n  return {\n    user: config.user,\n    outputDir: config.outputDir ?? DEFAULTS.outputDir,\n    interval: config.interval ?? DEFAULTS.interval,\n    duration: config.duration ?? DEFAULTS.duration,\n    logLevel: config.logLevel ?? DEFAULTS.logLevel,\n    logConsole: config.logConsole ?? DEFAULTS.logConsole,\n    proxy: config.proxy,\n    cookies: config.cookies,\n    cookiesPath: config.cookiesPath,\n    segmentMinutes: config.segmentMinutes ?? DEFAULTS.segmentMinutes,\n  }\n}\n\nexport function validateConfig(config: RecorderConfig): void {\n  if (!config.user || config.user.trim().length === 0) {\n    throw new TikTokError('config-error', '--user is required')\n  }\n  if (config.interval !== undefined && config.interval < 1) {\n    throw new TikTokError('config-error', '--interval must be >= 1 minute')\n  }\n  if (config.duration !== undefined && config.duration < 0) {\n    throw new TikTokError('config-error', '--duration must be >= 0 seconds')\n  }\n}\n"],"mappings":";AAkFA,IAAa,cAAb,cAAiC,MAAM;CAEnB;CAEA;CAHlB,YACE,MACA,SACA,OACA;EACA,MAAM,OAAO;EAJG,KAAA,OAAA;EAEA,KAAA,QAAA;EAGhB,KAAK,OAAO;CACd;AACF;AAEA,MAAM,WAAW;CACf,WAAW;CACX,UAAU;CACV,UAAU;CACV,UAAU;CACV,YAAY;CACZ,gBAAgB;AAClB;AAEA,SAAgB,gBACd,QAE0D;CAC1D,OAAO;EACL,MAAM,OAAO;EACb,WAAW,OAAO,aAAa,SAAS;EACxC,UAAU,OAAO,YAAY,SAAS;EACtC,UAAU,OAAO,YAAY,SAAS;EACtC,UAAU,OAAO,YAAY,SAAS;EACtC,YAAY,OAAO,cAAc,SAAS;EAC1C,OAAO,OAAO;EACd,SAAS,OAAO;EAChB,aAAa,OAAO;EACpB,gBAAgB,OAAO,kBAAkB,SAAS;CACpD;AACF;AAEA,SAAgB,eAAe,QAA8B;CAC3D,IAAI,CAAC,OAAO,QAAQ,OAAO,KAAK,KAAK,CAAC,CAAC,WAAW,GAChD,MAAM,IAAI,YAAY,gBAAgB,oBAAoB;CAE5D,IAAI,OAAO,aAAa,KAAA,KAAa,OAAO,WAAW,GACrD,MAAM,IAAI,YAAY,gBAAgB,gCAAgC;CAExE,IAAI,OAAO,aAAa,KAAA,KAAa,OAAO,WAAW,GACrD,MAAM,IAAI,YAAY,gBAAgB,iCAAiC;AAE3E"}

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env bun
+import { TikTokError, validateConfig } from "./config.mjs";
+import { bytesToHuman } from "./utils.mjs";
+import { createRecorder } from "./recorder/index.mjs";
+import "./lib.mjs";
+import { parseArgs } from "./cli.mjs";
+import { createDisplay } from "./ui.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { color } from "@zfadhli/koko-cli";
+//#region src/index.ts
+/**
+* Entry point — parses CLI args, creates the recorder, and handles signals.
+* Uses the terminal Display manager for beautiful console output.
+*/
+async function loadCookies(cookiesPath) {
+	const path = cookiesPath ?? join(process.cwd(), "cookies.json");
+	if (!existsSync(path)) return;
+	try {
+		const content = readFileSync(path, "utf-8");
+		const data = JSON.parse(content);
+		if (data.sessionid_ss && data.sessionid_ss.length > 0) return data;
+		return;
+	} catch {
+		return;
+	}
+}
+async function main() {
+	let config;
+	try {
+		config = parseArgs();
+		validateConfig(config);
+	} catch (err) {
+		if (err instanceof TikTokError && err.kind === "config-error") {
+			console.error(`${color.red("Error:")} ${err.message}`);
+			process.exit(1);
+		}
+		throw err;
+	}
+	const cookies = await loadCookies(config.cookiesPath);
+	if (cookies) config.cookies = cookies;
+	config.logConsole = false;
+	const display = createDisplay();
+	const recorder = createRecorder(config);
+	recorder.on("checking", (info) => {
+		display.checkingUser(info.user);
+	});
+	recorder.on("tick", (info) => {
+		if (info.isLive) display.userLive(info.user, info.roomId ?? "?");
+		else display.userOffline(info.user);
+	});
+	recorder.on("recording:start", () => {
+		display.startRecording();
+	});
+	recorder.on("download:progress", (info) => {
+		display.updateProgress(info.bytes, info.elapsed, info.speed);
+	});
+	recorder.on("download:end", (info) => {
+		const parsed = info.file.split("/").pop() ?? info.file;
+		const sizeStr = bytesToHuman(info.size);
+		display.finishRecording(parsed, info.duration, sizeStr);
+	});
+	recorder.on("segmenting:start", () => {
+		display.startSegmenting();
+	});
+	recorder.on("segmenting:end", (info) => {
+		display.segmentsCreated(info.segments);
+	});
+	recorder.on("converting:start", () => {
+		display.startConverting();
+	});
+	recorder.on("converted", () => {});
+	recorder.on("recording:end", () => {});
+	recorder.on("error", (err) => {
+		display.showError(`[${err.kind}] ${err.message}`);
+	});
+	let stopping = false;
+	const handleSignal = async () => {
+		if (stopping) {
+			process.stdout.write("  Force stopping...\n");
+			process.exit(1);
+		}
+		stopping = true;
+		display.showInfo("Shutting down gracefully...");
+		await recorder.stop();
+		display.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", handleSignal);
+	process.on("SIGTERM", handleSignal);
+	process.on("SIGHUP", handleSignal);
+	display.pollingStarted(config.interval ?? 3);
+	try {
+		await recorder.start();
+	} catch (err) {
+		if (err instanceof TikTokError) display.showError(`[${err.kind}] ${err.message}`);
+		else display.showError(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+		await recorder.stop();
+		display.stop();
+		process.exit(1);
+	}
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["#!/usr/bin/env bun\n/**\n * Entry point — parses CLI args, creates the recorder, and handles signals.\n * Uses the terminal Display manager for beautiful console output.\n */\n\nimport { existsSync, readFileSync } from 'node:fs'\nimport { join } from 'node:path'\nimport { color } from '@zfadhli/koko-cli'\nimport { parseArgs } from './cli'\nimport { TikTokError, validateConfig } from './config'\nimport type { RecorderConfig } from './config'\nimport { createRecorder } from './lib'\nimport { createDisplay } from './ui'\nimport { bytesToHuman } from './utils'\n\nasync function loadCookies(\n  cookiesPath?: string,\n): Promise<{ sessionid_ss: string; 'tt-target-idc'?: string } | undefined> {\n  const path = cookiesPath ?? join(process.cwd(), 'cookies.json')\n  if (!existsSync(path)) {\n    return undefined\n  }\n  try {\n    const content = readFileSync(path, 'utf-8')\n    const data = JSON.parse(content) as { sessionid_ss?: string; 'tt-target-idc'?: string }\n    if (data.sessionid_ss && data.sessionid_ss.length > 0) {\n      return data as { sessionid_ss: string; 'tt-target-idc'?: string }\n    }\n    return undefined\n  } catch {\n    return undefined\n  }\n}\n\nasync function main(): Promise<void> {\n  let config: RecorderConfig\n\n  try {\n    config = parseArgs()\n    validateConfig(config)\n  } catch (err) {\n    if (err instanceof TikTokError && err.kind === 'config-error') {\n      console.error(`${color.red('Error:')} ${err.message}`)\n      process.exit(1)\n    }\n    throw err\n  }\n\n  // Load cookies\n  const cookies = await loadCookies(config.cookiesPath)\n  if (cookies) {\n    config.cookies = cookies\n  }\n\n  // Suppress internal logger's console output — the Display owns the terminal\n  config.logConsole = false\n\n  // Beautiful terminal display\n  const display = createDisplay()\n\n  const recorder = createRecorder(config)\n\n  // Subscribe to events for beautiful console output\n  recorder.on('checking', (info) => {\n    display.checkingUser(info.user)\n  })\n\n  recorder.on('tick', (info) => {\n    if (info.isLive) {\n      display.userLive(info.user, info.roomId ?? '?')\n    } else {\n      display.userOffline(info.user)\n    }\n  })\n\n  recorder.on('recording:start', () => {\n    display.startRecording()\n  })\n\n  recorder.on('download:progress', (info) => {\n    display.updateProgress(info.bytes, info.elapsed, info.speed)\n  })\n\n  recorder.on('download:end', (info) => {\n    const parsed = info.file.split('/').pop() ?? info.file\n    const sizeStr = bytesToHuman(info.size)\n    display.finishRecording(parsed, info.duration, sizeStr)\n  })\n\n  recorder.on('segmenting:start', () => {\n    display.startSegmenting()\n  })\n\n  recorder.on('segmenting:end', (info) => {\n    display.segmentsCreated(info.segments)\n  })\n\n  recorder.on('converting:start', () => {\n    display.startConverting()\n  })\n\n  recorder.on('converted', () => {\n    // Individual conversion results acknowledged via segmenting:end or recording:end\n  })\n\n  recorder.on('recording:end', () => {\n    // For simple conversion (no segmenting), recording:end fires once.\n    // For segmenting path, segmenting:end already acknowledges the result.\n    // This is a no-op since we handle the terminal output through download:end\n    // and segmenting:end / converted events.\n  })\n\n  recorder.on('error', (err) => {\n    display.showError(`[${err.kind}] ${err.message}`)\n  })\n\n  // Signal handling\n  let stopping = false\n  const handleSignal = async () => {\n    if (stopping) {\n      process.stdout.write('  Force stopping...\\n')\n      process.exit(1)\n    }\n    stopping = true\n    display.showInfo('Shutting down gracefully...')\n    await recorder.stop()\n    display.stop()\n    process.exit(0)\n  }\n\n  process.on('SIGINT', handleSignal)\n  process.on('SIGTERM', handleSignal)\n  process.on('SIGHUP', handleSignal)\n\n  // Show initial status and start the recorder\n  display.pollingStarted(config.interval ?? 3)\n  try {\n    await recorder.start()\n  } catch (err) {\n    if (err instanceof TikTokError) {\n      display.showError(`[${err.kind}] ${err.message}`)\n    } else {\n      display.showError(`Unexpected error: ${err instanceof Error ? err.message : String(err)}`)\n    }\n    await recorder.stop()\n    display.stop()\n    process.exit(1)\n  }\n}\n\nmain()\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,eAAe,YACb,aACyE;CACzE,MAAM,OAAO,eAAe,KAAK,QAAQ,IAAI,GAAG,cAAc;CAC9D,IAAI,CAAC,WAAW,IAAI,GAClB;CAEF,IAAI;EACF,MAAM,UAAU,aAAa,MAAM,OAAO;EAC1C,MAAM,OAAO,KAAK,MAAM,OAAO;EAC/B,IAAI,KAAK,gBAAgB,KAAK,aAAa,SAAS,GAClD,OAAO;EAET;CACF,QAAQ;EACN;CACF;AACF;AAEA,eAAe,OAAsB;CACnC,IAAI;CAEJ,IAAI;EACF,SAAS,UAAU;EACnB,eAAe,MAAM;CACvB,SAAS,KAAK;EACZ,IAAI,eAAe,eAAe,IAAI,SAAS,gBAAgB;GAC7D,QAAQ,MAAM,GAAG,MAAM,IAAI,QAAQ,EAAE,GAAG,IAAI,SAAS;GACrD,QAAQ,KAAK,CAAC;EAChB;EACA,MAAM;CACR;CAGA,MAAM,UAAU,MAAM,YAAY,OAAO,WAAW;CACpD,IAAI,SACF,OAAO,UAAU;CAInB,OAAO,aAAa;CAGpB,MAAM,UAAU,cAAc;CAE9B,MAAM,WAAW,eAAe,MAAM;CAGtC,SAAS,GAAG,aAAa,SAAS;EAChC,QAAQ,aAAa,KAAK,IAAI;CAChC,CAAC;CAED,SAAS,GAAG,SAAS,SAAS;EAC5B,IAAI,KAAK,QACP,QAAQ,SAAS,KAAK,MAAM,KAAK,UAAU,GAAG;OAE9C,QAAQ,YAAY,KAAK,IAAI;CAEjC,CAAC;CAED,SAAS,GAAG,yBAAyB;EACnC,QAAQ,eAAe;CACzB,CAAC;CAED,SAAS,GAAG,sBAAsB,SAAS;EACzC,QAAQ,eAAe,KAAK,OAAO,KAAK,SAAS,KAAK,KAAK;CAC7D,CAAC;CAED,SAAS,GAAG,iBAAiB,SAAS;EACpC,MAAM,SAAS,KAAK,KAAK,MAAM,GAAG,CAAC,CAAC,IAAI,KAAK,KAAK;EAClD,MAAM,UAAU,aAAa,KAAK,IAAI;EACtC,QAAQ,gBAAgB,QAAQ,KAAK,UAAU,OAAO;CACxD,CAAC;CAED,SAAS,GAAG,0BAA0B;EACpC,QAAQ,gBAAgB;CAC1B,CAAC;CAED,SAAS,GAAG,mBAAmB,SAAS;EACtC,QAAQ,gBAAgB,KAAK,QAAQ;CACvC,CAAC;CAED,SAAS,GAAG,0BAA0B;EACpC,QAAQ,gBAAgB;CAC1B,CAAC;CAED,SAAS,GAAG,mBAAmB,CAE/B,CAAC;CAED,SAAS,GAAG,uBAAuB,CAKnC,CAAC;CAED,SAAS,GAAG,UAAU,QAAQ;EAC5B,QAAQ,UAAU,IAAI,IAAI,KAAK,IAAI,IAAI,SAAS;CAClD,CAAC;CAGD,IAAI,WAAW;CACf,MAAM,eAAe,YAAY;EAC/B,IAAI,UAAU;GACZ,QAAQ,OAAO,MAAM,uBAAuB;GAC5C,QAAQ,KAAK,CAAC;EAChB;EACA,WAAW;EACX,QAAQ,SAAS,6BAA6B;EAC9C,MAAM,SAAS,KAAK;EACpB,QAAQ,KAAK;EACb,QAAQ,KAAK,CAAC;CAChB;CAEA,QAAQ,GAAG,UAAU,YAAY;CACjC,QAAQ,GAAG,WAAW,YAAY;CAClC,QAAQ,GAAG,UAAU,YAAY;CAGjC,QAAQ,eAAe,OAAO,YAAY,CAAC;CAC3C,IAAI;EACF,MAAM,SAAS,MAAM;CACvB,SAAS,KAAK;EACZ,IAAI,eAAe,aACjB,QAAQ,UAAU,IAAI,IAAI,KAAK,IAAI,IAAI,SAAS;OAEhD,QAAQ,UAAU,qBAAqB,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAAG;EAE3F,MAAM,SAAS,KAAK;EACpB,QAAQ,KAAK;EACb,QAAQ,KAAK,CAAC;CAChB;AACF;AAEA,KAAK"}

package/dist/lib.d.mts

@@ -0,0 +1,3 @@
+import { AppErrorKind, RecorderConfig, RecorderController, RecorderEvent, RecorderEventHandler, RecorderStatus, TikTokError } from "./config.mjs";
+import { createRecorder } from "./recorder/index.mjs";
+export { type AppErrorKind, type RecorderConfig, type RecorderController, type RecorderEvent, type RecorderEventHandler, type RecorderStatus, type TikTokError, createRecorder };

package/dist/lib.mjs

@@ -0,0 +1,2 @@
+import { createRecorder } from "./recorder/index.mjs";
+export { createRecorder };