@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/domains/browser/handlers/camoufox-flow.d.ts

@@ -1,31 +0,0 @@
-import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
-export type CamoufoxWaitUntil = 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
-export type CamoufoxPage = Awaited<ReturnType<CamoufoxBrowserManager['newPage']>> & {
-    url(): string;
-    title(): Promise<string>;
-    goto(url: string, options?: {
-        waitUntil?: CamoufoxWaitUntil;
-        timeout?: number;
-    }): Promise<unknown>;
-};
-export interface CamoufoxLaunchFlowContext {
-    setCamoufoxManager: (manager: CamoufoxBrowserManager) => void;
-    setActiveDriver: (driver: 'chrome' | 'camoufox') => void;
-    clearCamoufoxPage: () => void;
-}
-export declare function handleCamoufoxLaunchFlow(context: CamoufoxLaunchFlowContext, args: Record<string, unknown>): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;
-export interface CamoufoxNavigateFlowContext {
-    getCamoufoxPage: () => Promise<CamoufoxPage>;
-    setConsoleMonitorPage: (page: CamoufoxPage) => void;
-}
-export declare function handleCamoufoxNavigateFlow(context: CamoufoxNavigateFlowContext, args: Record<string, unknown>): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-}>;

package/dist/src/server/domains/browser/handlers/camoufox-flow.js

@@ -1,92 +0,0 @@
-import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
-import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
-export async function handleCamoufoxLaunchFlow(context, args) {
-    const headless = argBool(args, 'headless', true);
-    const os = argString(args, 'os', 'windows');
-    const mode = argString(args, 'mode', 'launch');
-    if (mode === 'connect') {
-        const wsEndpoint = argString(args, 'wsEndpoint');
-        if (!wsEndpoint) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: 'wsEndpoint is required for connect mode.',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const manager = new CamoufoxBrowserManager({ headless, os });
-        await manager.connectToServer(wsEndpoint);
-        context.setCamoufoxManager(manager);
-        context.setActiveDriver('camoufox');
-        context.clearCamoufoxPage();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        driver: 'camoufox',
-                        mode: 'connect',
-                        wsEndpoint,
-                        message: 'Connected to Camoufox server.',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    const manager = new CamoufoxBrowserManager({ headless, os });
-    await manager.launch();
-    context.setCamoufoxManager(manager);
-    context.setActiveDriver('camoufox');
-    context.clearCamoufoxPage();
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    success: true,
-                    driver: 'camoufox',
-                    mode: 'launch',
-                    message: 'Camoufox (Firefox) browser launched',
-                }, null, 2),
-            },
-        ],
-    };
-}
-function normalizeWaitUntil(waitUntil) {
-    if (waitUntil === 'networkidle2')
-        return 'networkidle';
-    if (waitUntil === 'load')
-        return 'load';
-    if (waitUntil === 'domcontentloaded')
-        return 'domcontentloaded';
-    if (waitUntil === 'commit')
-        return 'commit';
-    return 'networkidle';
-}
-export async function handleCamoufoxNavigateFlow(context, args) {
-    const url = argString(args, 'url', '');
-    const rawWaitUntil = argString(args, 'waitUntil', 'networkidle');
-    const timeout = argNumber(args, 'timeout');
-    const page = await context.getCamoufoxPage();
-    await page.goto(url, { waitUntil: normalizeWaitUntil(rawWaitUntil), timeout });
-    context.setConsoleMonitorPage(page);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({
-                    success: true,
-                    driver: 'camoufox',
-                    url: page.url(),
-                    title: await page.title(),
-                }, null, 2),
-            },
-        ],
-    };
-}

package/dist/src/server/domains/browser/handlers/captcha-handlers.d.ts

@@ -1,35 +0,0 @@
-import type { PageController } from '../../../domains/shared/modules.js';
-import type { AICaptchaDetector } from '../../../domains/shared/modules.js';
-interface CaptchaHandlersDeps {
-    pageController: PageController;
-    captchaDetector: AICaptchaDetector;
-    autoDetectCaptcha: boolean;
-    autoSwitchHeadless: boolean;
-    captchaTimeout: number;
-    setAutoDetectCaptcha: (value: boolean) => void;
-    setAutoSwitchHeadless: (value: boolean) => void;
-    setCaptchaTimeout: (value: number) => void;
-}
-export declare class CaptchaHandlers {
-    private deps;
-    constructor(deps: CaptchaHandlersDeps);
-    handleCaptchaDetect(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleCaptchaWait(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleCaptchaConfig(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

package/dist/src/server/domains/browser/handlers/captcha-handlers.js

@@ -1,67 +0,0 @@
-import { argNumber, argBool } from '../../../domains/shared/parse-args.js';
-import { logger } from '../../../../utils/logger.js';
-export class CaptchaHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleCaptchaDetect(_args) {
-        const page = await this.deps.pageController.getPage();
-        const result = await this.deps.captchaDetector.detect(page);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        captcha_detected: result.detected,
-                        captcha_info: result,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleCaptchaWait(args) {
-        const timeout = argNumber(args, 'timeout', this.deps.captchaTimeout);
-        const page = await this.deps.pageController.getPage();
-        logger.info('Waiting for CAPTCHA to be solved...');
-        const completed = await this.deps.captchaDetector.waitForCompletion(page, timeout);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: completed,
-                        message: completed ? 'CAPTCHA solved' : 'CAPTCHA wait timed out',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleCaptchaConfig(args) {
-        if (args.autoDetectCaptcha !== undefined) {
-            this.deps.setAutoDetectCaptcha(argBool(args, 'autoDetectCaptcha', false));
-        }
-        if (args.autoSwitchHeadless !== undefined) {
-            this.deps.setAutoSwitchHeadless(argBool(args, 'autoSwitchHeadless', false));
-        }
-        if (args.captchaTimeout !== undefined) {
-            this.deps.setCaptchaTimeout(argNumber(args, 'captchaTimeout', 0));
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        config: {
-                            autoDetectCaptcha: this.deps.autoDetectCaptcha,
-                            autoSwitchHeadless: this.deps.autoSwitchHeadless,
-                            captchaTimeout: this.deps.captchaTimeout,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}

package/dist/src/server/domains/browser/handlers/captcha-solver.d.ts

@@ -1,3 +0,0 @@
-import type { CodeCollector } from '../../../domains/shared/modules.js';
-export declare function handleCaptchaVisionSolve(args: Record<string, unknown>, collector: CodeCollector): Promise<unknown>;
-export declare function handleWidgetChallengeSolve(args: Record<string, unknown>, collector: CodeCollector): Promise<unknown>;

package/dist/src/server/domains/browser/handlers/captcha-solver.js

@@ -1,332 +0,0 @@
-import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
-import { logger } from '../../../../utils/logger.js';
-import { CAPTCHA_SOLVER_BASE_URL, CAPTCHA_SUBMIT_TIMEOUT_MS, CAPTCHA_POLL_INTERVAL_MS, CAPTCHA_RESULT_TIMEOUT_MS, CAPTCHA_DEFAULT_TIMEOUT_MS, CAPTCHA_MIN_TIMEOUT_MS, CAPTCHA_MAX_TIMEOUT_MS, CAPTCHA_MAX_RETRIES, CAPTCHA_DEFAULT_RETRIES, } from '../../../../constants.js';
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function toTextResponse(payload) {
-    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
-}
-function toErrorResponse(tool, error, extra = {}) {
-    return toTextResponse({
-        success: false,
-        tool,
-        error: error instanceof Error ? error.message : String(error),
-        ...extra,
-    });
-}
-function normalizeSolverMode(rawMode) {
-    const value = typeof rawMode === 'string' ? rawMode.toLowerCase() : '';
-    if (value === 'hook')
-        return 'hook';
-    if (value === 'external_service')
-        return 'external_service';
-    if (value === '2captcha' || value === 'anticaptcha' || value === 'capsolver') {
-        return 'external_service';
-    }
-    return 'manual';
-}
-function normalizeChallengeTypeHint(rawType) {
-    const value = typeof rawType === 'string' ? rawType.toLowerCase() : '';
-    if (value === 'image')
-        return 'image';
-    if (value === 'widget' ||
-        value === 'recaptcha_v2' ||
-        value === 'recaptcha_v3' ||
-        value === 'hcaptcha' ||
-        value === 'funcaptcha' ||
-        value === 'turnstile') {
-        return 'widget';
-    }
-    if (value === 'browser_check' || value === 'managed_widget') {
-        return 'browser_check';
-    }
-    return 'auto';
-}
-function resolveLegacyServiceOverride(rawProvider) {
-    if (typeof rawProvider !== 'string' || !rawProvider.trim()) {
-        return undefined;
-    }
-    return rawProvider.trim().toLowerCase();
-}
-function resolveExternalServiceName(args) {
-    const legacyOverride = resolveLegacyServiceOverride(args.provider);
-    const configured = (process.env.CAPTCHA_PROVIDER || '').trim().toLowerCase();
-    return legacyOverride || configured || '2captcha';
-}
-async function solveWith2Captcha(apiKey, params, timeoutMs) {
-    const start = Date.now();
-    const baseUrl = CAPTCHA_SOLVER_BASE_URL;
-    if (!baseUrl) {
-        throw new Error('CAPTCHA_SOLVER_BASE_URL must be configured before using external_service mode.');
-    }
-    const submitBody = {
-        key: apiKey,
-        json: 1,
-    };
-    if (params.taskKind === 'turnstile' ||
-        params.taskKind === 'recaptcha_v2' ||
-        params.taskKind === 'hcaptcha') {
-        submitBody.method =
-            params.taskKind === 'turnstile'
-                ? 'turnstile'
-                : params.taskKind === 'hcaptcha'
-                    ? 'hcaptcha'
-                    : 'userrecaptcha';
-        submitBody.sitekey = params.siteKey;
-        submitBody.pageurl = params.pageUrl;
-    }
-    else {
-        submitBody.method = 'base64';
-        submitBody.body = params.imageBase64;
-    }
-    const submitRes = await fetch(`${baseUrl}/in.php`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(submitBody),
-        signal: AbortSignal.timeout(CAPTCHA_SUBMIT_TIMEOUT_MS),
-    });
-    const submitData = (await submitRes.json());
-    if (submitData.status !== 1) {
-        throw new Error(`2captcha submit failed: ${JSON.stringify(submitData)}`);
-    }
-    const taskId = submitData.request;
-    const pollInterval = CAPTCHA_POLL_INTERVAL_MS;
-    while (true) {
-        const remaining = timeoutMs - (Date.now() - start);
-        if (remaining <= 0)
-            break;
-        await sleep(Math.min(pollInterval, remaining));
-        if (Date.now() - start >= timeoutMs)
-            break;
-        const resultUrl = new URL(`${baseUrl}/res.php`);
-        resultUrl.searchParams.set('key', apiKey);
-        resultUrl.searchParams.set('action', 'get');
-        resultUrl.searchParams.set('id', taskId);
-        resultUrl.searchParams.set('json', '1');
-        const resultRes = await fetch(resultUrl.toString(), {
-            signal: AbortSignal.timeout(CAPTCHA_RESULT_TIMEOUT_MS),
-        });
-        const resultData = (await resultRes.json());
-        if (resultData.status === 1) {
-            return {
-                token: resultData.request,
-                challengeType: params.taskKind === 'image' ? 'image' : 'widget',
-                mode: 'external_service',
-                durationMs: Date.now() - start,
-            };
-        }
-        if (resultData.request !== 'CAPCHA_NOT_READY') {
-            throw new Error(`2captcha solve failed: ${JSON.stringify(resultData)}`);
-        }
-    }
-    throw new Error(`2captcha solve timeout after ${timeoutMs}ms`);
-}
-export async function handleCaptchaVisionSolve(args, collector) {
-    const page = await collector.getActivePage();
-    if (!page)
-        throw new Error('No active page.');
-    const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
-    const externalService = resolveExternalServiceName(args);
-    const apiKey = argString(args, 'apiKey', '') || process.env.CAPTCHA_API_KEY || '';
-    const challengeTypeHint = normalizeChallengeTypeHint(args.challengeType ?? args.typeHint);
-    const timeoutMs = Math.min(Math.max(argNumber(args, 'timeoutMs', CAPTCHA_DEFAULT_TIMEOUT_MS), CAPTCHA_MIN_TIMEOUT_MS), CAPTCHA_MAX_TIMEOUT_MS);
-    const maxRetries = Math.min(Math.max(argNumber(args, 'maxRetries', CAPTCHA_DEFAULT_RETRIES), 0), CAPTCHA_MAX_RETRIES);
-    let challengeType = challengeTypeHint;
-    let taskKind = challengeTypeHint === 'image' ? 'image' : 'recaptcha_v2';
-    let siteKey = argString(args, 'siteKey');
-    const pageUrl = argString(args, 'pageUrl', '') || page.url();
-    if (challengeType === 'auto') {
-        const detected = await page.evaluate(() => {
-            if (document.querySelector('[data-sitekey]')) {
-                const el = document.querySelector('[data-sitekey]');
-                const sk = el?.getAttribute('data-sitekey') || '';
-                if (document.querySelector('.cf-turnstile')) {
-                    return { challengeType: 'widget', taskKind: 'turnstile', siteKey: sk };
-                }
-                if (document.querySelector('.h-captcha')) {
-                    return { challengeType: 'widget', taskKind: 'hcaptcha', siteKey: sk };
-                }
-                return { challengeType: 'widget', taskKind: 'recaptcha_v2', siteKey: sk };
-            }
-            if (document.querySelector('iframe[src*="recaptcha"]')) {
-                return { challengeType: 'widget', taskKind: 'recaptcha_v2', siteKey: '' };
-            }
-            if (document.querySelector('iframe[src*="hcaptcha"]')) {
-                return { challengeType: 'widget', taskKind: 'hcaptcha', siteKey: '' };
-            }
-            if (document.querySelector('.cf-turnstile')) {
-                return { challengeType: 'widget', taskKind: 'turnstile', siteKey: '' };
-            }
-            return { challengeType: 'image', taskKind: 'image', siteKey: '' };
-        });
-        challengeType = detected.challengeType;
-        taskKind = detected.taskKind;
-        if (!siteKey && detected.siteKey)
-            siteKey = detected.siteKey;
-    }
-    else if (challengeType === 'image') {
-        taskKind = 'image';
-    }
-    else {
-        taskKind = 'recaptcha_v2';
-    }
-    if (mode === 'manual') {
-        return toTextResponse({
-            success: true,
-            mode: 'manual',
-            challengeType,
-            siteKey: siteKey ?? null,
-            instruction: 'Please solve the CAPTCHA manually in the browser, then continue.',
-            hint: 'Configure an external solver service and CAPTCHA_API_KEY to automate this flow.',
-        });
-    }
-    if (!apiKey) {
-        return toErrorResponse('captcha_vision_solve', new Error('External solver credentials are required. Set CAPTCHA_API_KEY.'));
-    }
-    let lastError = null;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            let result;
-            if (externalService === '2captcha') {
-                result = await solveWith2Captcha(apiKey, {
-                    taskKind,
-                    siteKey,
-                    pageUrl,
-                }, timeoutMs);
-            }
-            else if (externalService === 'anticaptcha' || externalService === 'capsolver') {
-                throw new Error('The selected external solver service is not yet implemented. ' +
-                    'Currently only the configured primary service and manual mode are supported.');
-            }
-            else {
-                throw new Error('Unsupported external solver service.');
-            }
-            return toTextResponse({
-                success: true,
-                token: result.token,
-                challengeType: result.challengeType,
-                mode: result.mode,
-                durationMs: result.durationMs,
-                attempt: attempt + 1,
-            });
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            logger.warn(`[captcha] Attempt ${attempt + 1} failed: ${lastError.message}`);
-        }
-    }
-    return toErrorResponse('captcha_vision_solve', lastError ?? new Error('All attempts failed'), {
-        challengeType,
-        mode,
-        maxRetries,
-        suggestion: 'Try manual mode or adjust the external solver configuration.',
-    });
-}
-export async function handleWidgetChallengeSolve(args, collector) {
-    const page = await collector.getActivePage();
-    if (!page)
-        throw new Error('No active page.');
-    const mode = normalizeSolverMode(args.mode ?? args.provider ?? process.env.CAPTCHA_PROVIDER);
-    const externalService = resolveExternalServiceName(args);
-    const apiKey = argString(args, 'apiKey', '') || process.env.CAPTCHA_API_KEY || '';
-    const timeoutMs = Math.min(Math.max(argNumber(args, 'timeoutMs', 120_000), 5_000), 600_000);
-    const injectToken = argBool(args, 'injectToken', true);
-    let siteKey = argString(args, 'siteKey');
-    const pageUrl = argString(args, 'pageUrl', '') || page.url();
-    if (!siteKey) {
-        siteKey =
-            (await page.evaluate(() => {
-                const el = document.querySelector('.cf-turnstile[data-sitekey], [data-sitekey]');
-                return el?.getAttribute('data-sitekey') ?? '';
-            })) || undefined;
-    }
-    if (!siteKey) {
-        return toErrorResponse('widget_challenge_solve', new Error('Could not detect the widget siteKey. Provide it manually or ensure the page exposes a site key.'));
-    }
-    if (mode === 'hook') {
-        const hookTimeoutMs = Math.min(timeoutMs, 30_000);
-        const token = await page
-            .evaluate((hookTimeout) => {
-            return new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => reject(new Error('Hook timeout')), hookTimeout);
-                const origCallbacks = window
-                    .__turnstile_callbacks;
-                if (origCallbacks) {
-                    for (const [key, cb] of Object.entries(origCallbacks)) {
-                        origCallbacks[key] = (captchaToken) => {
-                            clearTimeout(timeout);
-                            resolve(captchaToken);
-                            cb(captchaToken);
-                        };
-                    }
-                }
-                else {
-                    clearTimeout(timeout);
-                    reject(new Error('No widget callbacks found. Try external_service mode instead.'));
-                }
-            });
-        }, hookTimeoutMs)
-            .catch(() => null);
-        if (token) {
-            return toTextResponse({
-                success: true,
-                token,
-                method: 'hook',
-                challengeType: 'widget',
-                siteKey,
-            });
-        }
-    }
-    if (mode === 'manual') {
-        return toTextResponse({
-            success: true,
-            mode: 'manual',
-            challengeType: 'widget',
-            siteKey,
-            pageUrl,
-            instruction: 'Please complete the widget challenge manually.',
-        });
-    }
-    if (externalService !== '2captcha') {
-        return toErrorResponse('widget_challenge_solve', new Error('The selected external solver service is not implemented for this widget flow. ' +
-            'Currently only the configured primary service, manual mode, and hook mode are supported.'));
-    }
-    if (!apiKey) {
-        return toErrorResponse('widget_challenge_solve', new Error('External solver credentials are required.'));
-    }
-    try {
-        const result = await solveWith2Captcha(apiKey, {
-            taskKind: 'turnstile',
-            siteKey,
-            pageUrl,
-        }, timeoutMs);
-        if (injectToken && result.token) {
-            await page.evaluate((token) => {
-                const inputs = document.querySelectorAll('input[name*="turnstile"], input[name*="cf-turnstile"]');
-                inputs.forEach((input) => {
-                    input.value = token;
-                });
-                const cfTurnstile = window.turnstile;
-                if (cfTurnstile?.getResponse) {
-                }
-            }, result.token);
-        }
-        return toTextResponse({
-            success: true,
-            token: result.token,
-            challengeType: result.challengeType,
-            siteKey,
-            mode: result.mode,
-            durationMs: result.durationMs,
-            injected: injectToken,
-        });
-    }
-    catch (error) {
-        return toErrorResponse('widget_challenge_solve', error, {
-            siteKey,
-            mode,
-            suggestion: 'Try manual mode or hook mode.',
-        });
-    }
-}

package/dist/src/server/domains/browser/handlers/console-handlers.d.ts

@@ -1,29 +0,0 @@
-import type { ConsoleMonitor } from '../../../domains/shared/modules.js';
-import type { DetailedDataManager } from '../../../../utils/DetailedDataManager.js';
-interface ConsoleHandlersDeps {
-    consoleMonitor: ConsoleMonitor;
-    detailedDataManager: DetailedDataManager;
-}
-export declare class ConsoleHandlers {
-    private deps;
-    constructor(deps: ConsoleHandlersDeps);
-    handleConsoleEnable(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleGetLogs(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleConsoleExecute(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

package/dist/src/server/domains/browser/handlers/console-handlers.js

@@ -1,55 +0,0 @@
-import { argString, argNumber } from '../../../domains/shared/parse-args.js';
-export class ConsoleHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleConsoleEnable(_args) {
-        await this.deps.consoleMonitor.enable();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Console monitoring enabled',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleGetLogs(args) {
-        const type = argString(args, 'type');
-        const limit = argNumber(args, 'limit');
-        const since = argNumber(args, 'since');
-        const logs = this.deps.consoleMonitor.getLogs({ type, limit, since });
-        const result = {
-            count: logs.length,
-            logs,
-        };
-        const processedResult = this.deps.detailedDataManager.smartHandle(result, 51200);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(processedResult, null, 2),
-                },
-            ],
-        };
-    }
-    async handleConsoleExecute(args) {
-        const expression = argString(args, 'expression', '');
-        const result = await this.deps.consoleMonitor.execute(expression);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        result,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}

package/dist/src/server/domains/browser/handlers/detailed-data.d.ts

@@ -1,15 +0,0 @@
-import type { DetailedDataManager } from '../../../../utils/DetailedDataManager.js';
-interface DetailedDataHandlersDeps {
-    detailedDataManager: DetailedDataManager;
-}
-export declare class DetailedDataHandlers {
-    private deps;
-    constructor(deps: DetailedDataHandlersDeps);
-    handleGetDetailedData(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};