untiktok-api 1.0.0

package/dist/tiktok.js

@@ -0,0 +1,758 @@
+"use strict";
+// ============================================================
+// tiktok.ts
+// Mirrors TikTokApi/tiktok.py
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TikTokApi = exports.Logger = void 0;
+const crypto_1 = require("crypto");
+const url_1 = require("url");
+const exceptions_1 = require("./exceptions");
+const helpers_1 = require("./helpers");
+const stealth_1 = require("./stealth");
+const user_1 = require("./api/user");
+const video_1 = require("./api/video");
+const sound_1 = require("./api/sound");
+const hashtag_1 = require("./api/hashtag");
+const comment_1 = require("./api/comment");
+const trending_1 = require("./api/trending");
+const search_1 = require("./api/search");
+const playlist_1 = require("./api/playlist");
+class Logger {
+    constructor(name, level = "warn") {
+        this._levels = { debug: 0, info: 1, warn: 2, error: 3 };
+        this.name = name;
+        this.level = level;
+    }
+    _log(severity, message) {
+        if (this._levels[severity] >= this._levels[this.level]) {
+            const ts = new Date().toISOString();
+            console[severity === "warn" ? "warn" : severity](`${ts} - ${this.name} - ${severity.toUpperCase()} - ${message}`);
+        }
+    }
+    debug(msg) { this._log("debug", msg); }
+    info(msg) { this._log("info", msg); }
+    warn(msg) { this._log("warn", msg); }
+    error(msg) { this._log("error", msg); }
+}
+exports.Logger = Logger;
+// ---------------------------------------------------------------------------
+// TikTokApi
+// ---------------------------------------------------------------------------
+class TikTokApi {
+    constructor(options = {}) {
+        // ── State ──
+        this.sessions = [];
+        this.browser = null;
+        this.playwright = null;
+        this._sessionRecoveryEnabled = true;
+        this._sessionCreationLock = false;
+        this._cleanupCalled = false;
+        this._autoCleanupDeadSessions = true;
+        this._playwrightInstance = null;
+        this._userAgent = null;
+        const { loggingLevel = "warn", loggerName } = options;
+        this.logger = new Logger(loggerName ?? "TikTokApi", loggingLevel);
+        this.trending = new trending_1.Trending(this);
+        this.search = new search_1.Search(this);
+        // Wire static parent references
+    }
+    // ── Factory methods (mirror Python's api.user(), api.video(), etc.) ──
+    user(options) {
+        return new user_1.User(this, options);
+    }
+    video(options) {
+        return new video_1.Video(this, options);
+    }
+    sound(options) {
+        return new sound_1.Sound(this, options);
+    }
+    hashtag(options) {
+        return new hashtag_1.Hashtag(this, options);
+    }
+    comment(options) {
+        return new comment_1.Comment(this, options.data);
+    }
+    playlist(options) {
+        return new playlist_1.Playlist(this, options);
+    }
+    // ── Session params ──
+    async _setSessionParams(session) {
+        const page = session.page;
+        // Pass as string expressions so TypeScript never sees browser-only globals
+        const userAgent = await page.evaluate("navigator.userAgent");
+        const language = await page.evaluate("navigator.language || navigator.userLanguage || 'en'");
+        const platform = await page.evaluate("navigator.platform");
+        const timezone = await page.evaluate("Intl.DateTimeFormat().resolvedOptions().timeZone");
+        const deviceId = String(BigInt((0, crypto_1.randomInt)(2 ** 30)) * BigInt(2 ** 30) + BigInt((0, crypto_1.randomInt)(2 ** 30)));
+        const historyLen = String((0, crypto_1.randomInt)(1, 11));
+        const screenHeight = String((0, crypto_1.randomInt)(600, 1081));
+        const screenWidth = String((0, crypto_1.randomInt)(800, 1921));
+        session.params = {
+            aid: "1988",
+            app_language: language,
+            app_name: "tiktok_web",
+            browser_language: language,
+            browser_name: "Mozilla",
+            browser_online: "true",
+            browser_platform: platform,
+            browser_version: userAgent,
+            channel: "tiktok_web",
+            cookie_enabled: "true",
+            device_id: deviceId,
+            device_platform: "web_pc",
+            focus_state: "true",
+            from_page: "user",
+            history_len: historyLen,
+            is_fullscreen: "false",
+            is_page_visible: "true",
+            language,
+            os: platform,
+            priority_region: "",
+            referer: "",
+            region: "US",
+            screen_height: screenHeight,
+            screen_width: screenWidth,
+            tz_name: timezone,
+            webcast_language: language,
+        };
+    }
+    // ── Session validation ──
+    async _isSessionValid(session) {
+        if (!session.isValid)
+            return false;
+        try {
+            // Accessing .url throws if page/context is closed
+            void session.page.url();
+            return true;
+        }
+        catch (e) {
+            this.logger.warn(`Session validation failed: ${e}`);
+            session.isValid = false;
+            return false;
+        }
+    }
+    async _markSessionInvalid(session) {
+        session.isValid = false;
+        try {
+            await session.page.close();
+        }
+        catch (e) {
+            this.logger.debug(`Error closing page during invalidation: ${e}`);
+        }
+        try {
+            await session.context.close();
+        }
+        catch (e) {
+            this.logger.debug(`Error closing context during invalidation: ${e}`);
+        }
+        if (this._autoCleanupDeadSessions) {
+            const idx = this.sessions.indexOf(session);
+            if (idx !== -1) {
+                this.sessions.splice(idx, 1);
+                this.logger.debug(`Automatically removed dead session. Remaining: ${this.sessions.length}`);
+            }
+        }
+    }
+    async _getValidSessionIndex(kwargs = {}) {
+        const maxAttempts = 3;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (kwargs.sessionIndex != null) {
+                const i = kwargs.sessionIndex;
+                if (i < this.sessions.length) {
+                    const session = this.sessions[i];
+                    if (await this._isSessionValid(session))
+                        return [i, session];
+                    this.logger.warn(`Requested session ${i} is invalid`);
+                }
+            }
+            else {
+                const validSessions = [];
+                for (let idx = 0; idx < this.sessions.length; idx++) {
+                    if (await this._isSessionValid(this.sessions[idx])) {
+                        validSessions.push([idx, this.sessions[idx]]);
+                    }
+                }
+                if (validSessions.length > 0) {
+                    return validSessions[(0, crypto_1.randomInt)(0, validSessions.length)];
+                }
+            }
+            if (this._sessionRecoveryEnabled && attempt < maxAttempts - 1) {
+                this.logger.warn(`No valid sessions found, attempting recovery (attempt ${attempt + 1}/${maxAttempts})`);
+                await this._recoverSessions();
+            }
+            else {
+                break;
+            }
+        }
+        throw new Error("No valid sessions available. All sessions appear to be dead. " +
+            "Please call createSessions() again.");
+    }
+    async _recoverSessions() {
+        if (this._sessionCreationLock)
+            return;
+        this._sessionCreationLock = true;
+        try {
+            this.logger.info("Starting session recovery...");
+            const initial = this.sessions.length;
+            const validSessions = [];
+            for (const s of this.sessions) {
+                if (await this._isSessionValid(s))
+                    validSessions.push(s);
+            }
+            this.sessions = validSessions;
+            const removed = initial - this.sessions.length;
+            if (removed > 0)
+                this.logger.info(`Removed ${removed} dead session(s)`);
+        }
+        finally {
+            this._sessionCreationLock = false;
+        }
+    }
+    // ── _getSession (deprecated but kept for compat) ──
+    _getSession(kwargs = {}) {
+        if (this.sessions.length === 0) {
+            throw new Error("No sessions created, please create sessions first");
+        }
+        const i = kwargs.sessionIndex ?? (0, crypto_1.randomInt)(0, this.sessions.length);
+        return [i, this.sessions[i]];
+    }
+    // ── Create sessions ──
+    async createSessions(options = {}) {
+        const { numSessions = 5, headless = true, msTokens = null, proxies = null, sleepAfter = 1, startingUrl = "https://www.tiktok.com", contextOptions = {}, overrideBrowserArgs = null, cookies = null, suppressResourceLoadTypes = null, browser: browserName = "chromium", executablePath = null, pageFactory = null, browserContextFactory = null, timeout = 30000, enableSessionRecovery = true, allowPartialSessions = false, minSessions = null, } = options;
+        this._sessionRecoveryEnabled = enableSessionRecovery;
+        // Start Playwright
+        const { chromium: pw_chromium, firefox: pw_firefox, webkit: pw_webkit } = await Promise.resolve().then(() => __importStar(require("playwright")));
+        if (browserContextFactory) {
+            // Custom factory: call it and store the returned context/browser
+            const factoryResult = await browserContextFactory(null);
+            // browserContextFactory returns a BrowserContext, but we store it as Browser
+            // so that _createSession can call newContext() on it — however when
+            // browserContextFactory is provided, _createSession skips newContext().
+            this.browser = factoryResult;
+        }
+        else {
+            let launchArgs = overrideBrowserArgs ?? undefined;
+            let finalHeadless = headless;
+            if (browserName === "chromium") {
+                if (headless && !overrideBrowserArgs) {
+                    launchArgs = ["--headless=new"];
+                    finalHeadless = false;
+                }
+                this.browser = await pw_chromium.launch({
+                    headless: finalHeadless,
+                    args: launchArgs,
+                    proxy: proxyToPlaywright((0, helpers_1.randomChoice)(proxies)),
+                    executablePath: executablePath ?? undefined,
+                });
+            }
+            else if (browserName === "firefox") {
+                this.browser = await pw_firefox.launch({
+                    headless: finalHeadless,
+                    args: launchArgs,
+                    proxy: proxyToPlaywright((0, helpers_1.randomChoice)(proxies)),
+                    executablePath: executablePath ?? undefined,
+                });
+            }
+            else if (browserName === "webkit") {
+                this.browser = await pw_webkit.launch({
+                    headless: finalHeadless,
+                    args: launchArgs,
+                    proxy: proxyToPlaywright((0, helpers_1.randomChoice)(proxies)),
+                    executablePath: executablePath ?? undefined,
+                });
+            }
+            else {
+                throw new Error("Invalid browser argument. Use 'chromium', 'firefox', or 'webkit'.");
+            }
+        }
+        // Detect dynamic User-Agent to avoid Chrome version mismatches in headless mode
+        let resolvedUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+        if (this.browser && browserName === "chromium") {
+            try {
+                const tempContext = await this.browser.newContext();
+                const tempPage = await tempContext.newPage();
+                const rawUA = await tempPage.evaluate("navigator.userAgent");
+                resolvedUA = rawUA.replace("HeadlessChrome", "Chrome");
+                await tempPage.close();
+                await tempContext.close();
+            }
+            catch (e) {
+                // Use hardcoded fallback
+            }
+        }
+        this._userAgent = resolvedUA;
+        const createOne = () => this._createSession({
+            url: startingUrl,
+            msToken: (0, helpers_1.randomChoice)(msTokens),
+            proxy: (0, helpers_1.randomChoice)(proxies),
+            contextOptions,
+            sleepAfter,
+            cookies: (0, helpers_1.randomChoice)(cookies),
+            suppressResourceLoadTypes,
+            timeout,
+            pageFactory,
+            browserContextFactory,
+        });
+        if (allowPartialSessions) {
+            const results = await Promise.allSettled(Array.from({ length: numSessions }, createOne));
+            const failed = results.filter((r) => r.status === "rejected").length;
+            const succeeded = this.sessions.length;
+            const minRequired = minSessions ?? 1;
+            if (succeeded < minRequired) {
+                const errors = results
+                    .filter((r) => r.status === "rejected")
+                    .slice(0, 3)
+                    .map((r) => String(r.reason));
+                throw new Error(`Failed to create minimum required sessions. Created ${succeeded}/${numSessions}, needed ${minRequired}.\n` +
+                    `Errors: ${errors.join("; ")}`);
+            }
+            if (failed > 0) {
+                this.logger.warn(`Created ${succeeded}/${numSessions} sessions. ${failed} failed.`);
+            }
+        }
+        else {
+            await Promise.all(Array.from({ length: numSessions }, createOne));
+        }
+    }
+    async _createSession(options) {
+        const { url = "https://www.tiktok.com", msToken = null, proxy, contextOptions = {}, sleepAfter = 1, suppressResourceLoadTypes = null, timeout = 30000, pageFactory = null, } = options;
+        let { cookies = null } = options;
+        let context;
+        let page;
+        try {
+            if (msToken != null) {
+                cookies = cookies ?? {};
+                cookies["msToken"] = msToken;
+            }
+            let defaultUA = this._userAgent;
+            if (!defaultUA) {
+                defaultUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+            }
+            context = await this.browser.newContext({
+                proxy: proxyToPlaywright(proxy),
+                userAgent: defaultUA,
+                ...contextOptions,
+            });
+            if (cookies) {
+                const hostname = new url_1.URL(url).hostname;
+                const formattedCookies = Object.entries(cookies)
+                    .filter(([, v]) => v != null)
+                    .map(([name, value]) => ({
+                    name,
+                    value,
+                    domain: hostname,
+                    path: "/",
+                }));
+                await context.addCookies(formattedCookies);
+            }
+            const applySuppression = async (p) => {
+                if (!suppressResourceLoadTypes)
+                    return;
+                await p.route("**/*", (route, request) => {
+                    if (suppressResourceLoadTypes.includes(request.resourceType())) {
+                        void route.abort();
+                    }
+                    else {
+                        void route.continue();
+                    }
+                });
+            };
+            if (pageFactory) {
+                page = await pageFactory(context);
+            }
+            else {
+                page = await context.newPage();
+                await (0, stealth_1.stealthAsync)(page); // apply anti-bot stealth scripts
+                await applySuppression(page);
+                await page.goto(url);
+            }
+            if (!page.url().includes("tiktok")) {
+                await page.goto("https://www.tiktok.com");
+            }
+            let requestHeaders = null;
+            page.once("request", (request) => {
+                requestHeaders = request.headers();
+            });
+            if (pageFactory) {
+                await applySuppression(page);
+            }
+            page.setDefaultNavigationTimeout(timeout);
+            // Simulate scrolling to avoid bot detection
+            const x = (0, crypto_1.randomInt)(0, 51);
+            const y = (0, crypto_1.randomInt)(0, 51);
+            const a = (0, crypto_1.randomInt)(1, 51);
+            const b = (0, crypto_1.randomInt)(100, 201);
+            await page.mouse.move(x, y);
+            try {
+                await page.waitForLoadState("networkidle", { timeout: 15000 });
+            }
+            catch (e) {
+                this.logger.debug(`networkidle timeout during session creation, continuing...`);
+            }
+            await page.mouse.move(a, b);
+            const session = {
+                context,
+                page,
+                msToken,
+                proxy: proxy,
+                headers: requestHeaders,
+                baseUrl: url,
+                isValid: true,
+            };
+            let finalMsToken = msToken;
+            if (finalMsToken == null) {
+                await (0, helpers_1.sleep)(sleepAfter * 1000);
+                const sessionCookies = await this.getSessionCookies(session);
+                finalMsToken = sessionCookies["msToken"] ?? null;
+                session.msToken = finalMsToken;
+                if (!finalMsToken) {
+                    this.logger.info(`Failed to get msToken on session index ${this.sessions.length}, consider specifying ms_tokens`);
+                }
+            }
+            this.sessions.push(session);
+            await this._setSessionParams(session);
+        }
+        catch (e) {
+            this.logger.error(`Failed to create session: ${e}`);
+            throw e;
+        }
+    }
+    // ── Cookie helpers ──
+    async setSessionCookies(session, cookies) {
+        // Cast via unknown to satisfy Playwright's strict cookie type
+        await session.context.addCookies(cookies);
+    }
+    async getSessionCookies(session) {
+        const cookies = await session.context.cookies();
+        return Object.fromEntries(cookies.map((c) => [c.name, c.value]));
+    }
+    // ── JS fetch / XBogus / Sign ──
+    async runFetchScript(url, headers, kwargs = {}) {
+        let session;
+        try {
+            [, session] = await this._getValidSessionIndex(kwargs);
+        }
+        catch {
+            [, session] = this._getSession(kwargs);
+        }
+        try {
+            return (await session.page.evaluate(async ({ fetchUrl, fetchHeaders }) => {
+                const response = await fetch(fetchUrl, { method: 'GET', headers: fetchHeaders });
+                return await response.text();
+            }, { fetchUrl: url, fetchHeaders: headers }));
+        }
+        catch (e) {
+            this.logger.error(`Session failed during fetch: ${e}`);
+            await this._markSessionInvalid(session);
+            throw e;
+        }
+    }
+    async generateXBogus(url, kwargs = {}) {
+        let session;
+        try {
+            [, session] = await this._getValidSessionIndex(kwargs);
+        }
+        catch {
+            [, session] = this._getSession(kwargs);
+        }
+        const maxAttempts = 5;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const timeoutMs = (0, crypto_1.randomInt)(5000, 20001);
+                await session.page.waitForFunction("typeof window !== 'undefined' && window.byted_acrawler !== undefined", { timeout: timeoutMs });
+                break;
+            }
+            catch (e) {
+                if (attempt === maxAttempts - 1) {
+                    // eslint-disable-next-line preserve-caught-error
+                    throw new Error(`Failed to load tiktok after ${maxAttempts} attempts, consider using a proxy`);
+                }
+                const tryUrls = [
+                    "https://www.tiktok.com/foryou",
+                    "https://www.tiktok.com",
+                    "https://www.tiktok.com/@tiktok",
+                ];
+                await session.page.goto(tryUrls[(0, crypto_1.randomInt)(0, tryUrls.length)]);
+            }
+        }
+        try {
+            const result = await session.page.evaluate(`window.byted_acrawler.frontierSign("${url}")`);
+            return result;
+        }
+        catch (e) {
+            this.logger.error(`Session died during x-bogus evaluation: ${e}`);
+            await this._markSessionInvalid(session);
+            throw e;
+        }
+    }
+    async signUrl(url, kwargs = {}) {
+        let i;
+        let session;
+        try {
+            [i, session] = await this._getValidSessionIndex(kwargs);
+        }
+        catch {
+            [i, session] = this._getSession(kwargs);
+        }
+        const xBogus = (await this.generateXBogus(url, { sessionIndex: i }))["X-Bogus"];
+        if (!xBogus)
+            throw new Error("Failed to generate X-Bogus");
+        return url + (url.includes("?") ? "&" : "?") + `X-Bogus=${xBogus}`;
+    }
+    // ── Session Storage ──
+    /**
+     * Saves the current Playwright browser context state (cookies, local storage) to a file.
+     * You can load this state back by passing \`contextOptions: { storageState: "path.json" }\` to \`createSessions\`.
+     */
+    async saveSessionState(path, sessionIndex = 0) {
+        if (this.sessions.length <= sessionIndex) {
+            throw new Error(`Session index ${sessionIndex} does not exist`);
+        }
+        const session = this.sessions[sessionIndex];
+        if (session.context) {
+            await session.context.storageState({ path });
+            this.logger.info(`Session state saved to ${path}`);
+        }
+    }
+    // ── makeRequest ──
+    async makeRequest(options) {
+        const { url, headers: extraHeaders = null, params: extraParams = null, retries = 3, exponentialBackoff = true, sessionIndex, } = options;
+        let i;
+        let session;
+        try {
+            [i, session] = await this._getValidSessionIndex({ sessionIndex });
+        }
+        catch {
+            [i, session] = this._getSession({ sessionIndex });
+        }
+        // Python: if session.params is not None: params = {**session.params, **params}
+        // Always merge — extraParams may be null/undefined
+        const params = {
+            ...(session.params ?? {}),
+            ...(extraParams ?? {}),
+        };
+        // Python: if headers is not None: headers = {**session.headers, **headers} else: headers = session.headers
+        const headers = extraHeaders
+            ? { ...(session.headers ?? {}), ...extraHeaders }
+            : { ...(session.headers ?? {}) };
+        // Ensure msToken
+        if (!params["msToken"]) {
+            if (session.msToken) {
+                params["msToken"] = session.msToken;
+            }
+            else {
+                const cookieMap = await this.getSessionCookies(session);
+                const msTok = cookieMap["msToken"];
+                if (!msTok) {
+                    // Python uses self.logger.warn (same as .warning in Python logging)
+                    this.logger.warn("Failed to get msToken from cookies, trying to make the request anyway (probably will fail)");
+                }
+                params["msToken"] = msTok;
+            }
+        }
+        const encodedParams = new URLSearchParams(Object.fromEntries(Object.entries(params)
+            .filter(([, v]) => v != null)
+            .map(([k, v]) => [k, String(v)]))).toString();
+        const fullUrl = `${url}?${encodedParams}`;
+        const signedUrl = await this.signUrl(fullUrl, { sessionIndex: i });
+        let retryCount = 0;
+        while (retryCount < retries) {
+            retryCount++;
+            try {
+                const result = await this.runFetchScript(signedUrl, headers, { sessionIndex: i });
+                if (result == null)
+                    throw new Error("runFetchScript returned null");
+                if (result === "") {
+                    throw new exceptions_1.EmptyResponseException(result, "TikTok returned an empty response. They are detecting you're a bot. " +
+                        "Try: headless=false, browser='webkit', or a proxy.");
+                }
+                try {
+                    const data = JSON.parse(result);
+                    if (data["status_code"] !== 0) {
+                        this.logger.error(`Got unexpected status code: ${JSON.stringify(data)}`);
+                    }
+                    return data;
+                }
+                catch {
+                    if (retryCount === retries) {
+                        this.logger.error(`Failed to decode JSON response: ${result}`);
+                        throw new exceptions_1.InvalidJSONException(result);
+                    }
+                    this.logger.info(`Failed a request, retrying (${retryCount}/${retries})`);
+                    if (exponentialBackoff) {
+                        await (0, helpers_1.sleep)(2 ** retryCount * 1000);
+                    }
+                    else {
+                        await (0, helpers_1.sleep)(1000);
+                    }
+                }
+            }
+            catch (e) {
+                if (e instanceof exceptions_1.EmptyResponseException || e instanceof exceptions_1.InvalidJSONException)
+                    throw e;
+                this.logger.error(`Playwright error during request: ${e}`);
+                await this._markSessionInvalid(session);
+                if (retryCount < retries) {
+                    this.logger.info(`Retrying with a new session (${retryCount}/${retries})`);
+                    try {
+                        [i, session] = await this._getValidSessionIndex({ sessionIndex });
+                    }
+                    catch (sessionErr) {
+                        this.logger.error(`Failed to get valid session: ${sessionErr}`);
+                        throw sessionErr;
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        throw new Error("makeRequest: exhausted all retries");
+    }
+    // ── Close / cleanup ──
+    async closeSessions() {
+        this.logger.debug(`Closing ${this.sessions.length} sessions...`);
+        for (const session of this.sessions) {
+            try {
+                await session.page.close();
+            }
+            catch (e) {
+                this.logger.debug(`Error closing page: ${e}`);
+            }
+            try {
+                await session.context.close();
+            }
+            catch (e) {
+                this.logger.debug(`Error closing context: ${e}`);
+            }
+        }
+        this.sessions = [];
+        try {
+            if (this.browser) {
+                await this.browser.close();
+                this.browser = null;
+            }
+        }
+        catch (e) {
+            this.logger.debug(`Error closing browser: ${e}`);
+        }
+        this._cleanupCalled = true;
+        this.logger.debug("All sessions and browser resources closed successfully");
+    }
+    async stopPlaywright() {
+        // Python also calls self.playwright.stop() — we store it on this.playwright
+        try {
+            if (this.browser) {
+                await this.browser.close();
+                this.browser = null;
+            }
+        }
+        catch (e) {
+            this.logger.debug(`Error closing browser: ${e}`);
+        }
+        // Python also stops playwright instance (equivalent of playwright.stop())
+        // We don't hold the playwright instance separately, browser.close() covers it.
+    }
+    async getSessionContent(url, kwargs = {}) {
+        let session;
+        try {
+            [, session] = await this._getValidSessionIndex(kwargs);
+        }
+        catch {
+            [, session] = this._getSession(kwargs);
+        }
+        try {
+            return await session.page.content();
+        }
+        catch (e) {
+            this.logger.error(`Session died during getSessionContent: ${e}`);
+            await this._markSessionInvalid(session);
+            throw e;
+        }
+    }
+    // ── Resource stats / health ──
+    getResourceStats() {
+        const validSessions = this.sessions.filter((s) => s.isValid).length;
+        return {
+            totalSessions: this.sessions.length,
+            validSessions,
+            invalidSessions: this.sessions.length - validSessions,
+            hasBrowser: this.browser != null,
+            hasPlaywright: false,
+            cleanupCalled: this._cleanupCalled,
+            autoCleanupEnabled: this._autoCleanupDeadSessions,
+            recoveryEnabled: this._sessionRecoveryEnabled,
+        };
+    }
+    async healthCheck() {
+        const health = this.getResourceStats();
+        const sessionDetails = await Promise.all(this.sessions.map(async (s, i) => ({
+            index: i,
+            valid: await this._isSessionValid(s),
+            markedValid: s.isValid,
+        })));
+        health.sessionDetails = sessionDetails;
+        health.healthySessions = sessionDetails.filter((s) => s.valid).length;
+        if (health.invalidSessions > 0 && !this._autoCleanupDeadSessions) {
+            health.warning = `${health.invalidSessions} invalid sessions accumulating (auto-cleanup disabled)`;
+        }
+        return health;
+    }
+    // ── Context manager (using/Symbol.asyncDispose) ──
+    async [Symbol.asyncDispose]() {
+        await this.closeSessions();
+    }
+}
+exports.TikTokApi = TikTokApi;
+// ---------------------------------------------------------------------------
+// Helper: convert proxy string or object to Playwright proxy format
+// ---------------------------------------------------------------------------
+function proxyToPlaywright(proxy) {
+    if (!proxy)
+        return undefined;
+    if (typeof proxy === "string")
+        return { server: proxy };
+    if (typeof proxy === "object") {
+        const p = proxy;
+        return {
+            server: p["server"] ?? p["http"] ?? p["https"] ?? "",
+            username: p["username"],
+            password: p["password"],
+        };
+    }
+    return undefined;
+}