@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-common.js

@@ -1,146 +0,0 @@
-import { SourcemapToolHandlersParseBase } from '../../domains/sourcemap/handlers.impl.sourcemap-parse-base.js';
-export class SourcemapToolHandlersCommon extends SourcemapToolHandlersParseBase {
-    combineSourceRoot(sourceRoot, sourcePath) {
-        if (!sourceRoot) {
-            return sourcePath;
-        }
-        if (!sourcePath) {
-            return sourceRoot;
-        }
-        if (this.hasProtocol(sourcePath) || sourcePath.startsWith('/')) {
-            return sourcePath;
-        }
-        if (this.hasProtocol(sourceRoot)) {
-            try {
-                const base = sourceRoot.endsWith('/') ? sourceRoot : `${sourceRoot}/`;
-                return new URL(sourcePath, base).toString();
-            }
-            catch {
-                return `${sourceRoot.replace(/\/+$/g, '')}/${sourcePath.replace(/^\/+/g, '')}`;
-            }
-        }
-        return `${sourceRoot.replace(/\/+$/g, '')}/${sourcePath.replace(/^\/+/g, '')}`;
-    }
-    normalizeSourcePath(sourcePath, index) {
-        let candidate = sourcePath.trim();
-        if (!candidate) {
-            return `source_${index + 1}.js`;
-        }
-        if (candidate.startsWith('webpack://')) {
-            candidate = candidate.slice('webpack://'.length);
-        }
-        if (candidate.startsWith('data:')) {
-            return `inline/source_${index + 1}.txt`;
-        }
-        if (this.hasProtocol(candidate)) {
-            try {
-                const parsed = new URL(candidate);
-                candidate = `${parsed.hostname}${parsed.pathname}`;
-            }
-            catch {
-                candidate = candidate.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, '');
-            }
-        }
-        candidate = candidate.replace(/[?#].*$/g, '');
-        candidate = candidate.replace(/^[A-Za-z]:[\\/]/, '');
-        candidate = candidate.replace(/^\/+/, '');
-        const parts = candidate
-            .split(/[\\/]+/)
-            .map((segment) => this.sanitizePathSegment(segment))
-            .filter((segment) => segment !== '' && segment !== '.' && segment !== '..');
-        if (parts.length === 0) {
-            return `source_${index + 1}.js`;
-        }
-        return parts.join('/');
-    }
-    sanitizePathSegment(segment) {
-        const sanitized = Array.from(segment, (char) => {
-            const codePoint = char.codePointAt(0);
-            return codePoint !== undefined && (codePoint <= 0x1f || '<>:"|?*'.includes(char))
-                ? '_'
-                : char;
-        })
-            .join('')
-            .replace(/\s+/g, ' ')
-            .trim();
-        if (!sanitized || sanitized === '.' || sanitized === '..') {
-            return '_';
-        }
-        return sanitized;
-    }
-    safeTarget(value) {
-        return value
-            .replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, '')
-            .replace(/[^a-zA-Z0-9_-]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .slice(0, 48);
-    }
-    hasProtocol(value) {
-        return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value);
-    }
-    parseBooleanArg(value, defaultValue) {
-        return typeof value === 'boolean' ? value : defaultValue;
-    }
-    requiredStringArg(value, fieldName) {
-        if (typeof value !== 'string' || value.trim().length === 0) {
-            throw new Error(`${fieldName} is required`);
-        }
-        return value.trim();
-    }
-    optionalStringArg(value) {
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
-    }
-    asRecord(value) {
-        return typeof value === 'object' && value !== null ? value : {};
-    }
-    asString(value) {
-        return typeof value === 'string' ? value : undefined;
-    }
-    async safeDetach(session) {
-        if (!session.detach) {
-            return;
-        }
-        try {
-            await session.detach();
-        }
-        catch {
-            return;
-        }
-    }
-    async trySend(session, method, params) {
-        try {
-            await session.send(method, params);
-        }
-        catch {
-            return;
-        }
-    }
-    async delay(ms) {
-        await new Promise((resolvePromise) => {
-            setTimeout(() => resolvePromise(), ms);
-        });
-    }
-    json(payload) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(payload, null, 2),
-                },
-            ],
-        };
-    }
-    fail(tool, error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return this.json({
-            success: false,
-            tool,
-            error: message,
-        });
-    }
-}

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-extension.d.ts

@@ -1,13 +0,0 @@
-import type { CdpSessionLike, ExtensionTarget, TextToolResponse } from '../../domains/sourcemap/handlers.impl.sourcemap-parse-base.js';
-import { SourcemapToolHandlersCommon } from '../../domains/sourcemap/handlers.impl.sourcemap-common.js';
-export declare class SourcemapToolHandlersExtension extends SourcemapToolHandlersCommon {
-    handleExtensionListInstalled(_args: Record<string, unknown>): Promise<TextToolResponse>;
-    handleExtensionExecuteInContext(args: Record<string, unknown>): Promise<TextToolResponse>;
-    protected getExtensionTargets(session: CdpSessionLike, expectedExtensionId?: string): Promise<ExtensionTarget[]>;
-    protected pickPreferredExtensionTarget(targets: ExtensionTarget[]): ExtensionTarget;
-    protected extractExtensionId(url: string): string | null;
-    protected evaluateInAttachedTarget(session: CdpSessionLike, sessionId: string, code: string, returnByValue: boolean): Promise<{
-        result: unknown;
-        exceptionDetails: unknown;
-    }>;
-}

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-extension.js

@@ -1,189 +0,0 @@
-import { SourcemapToolHandlersCommon } from '../../domains/sourcemap/handlers.impl.sourcemap-common.js';
-export class SourcemapToolHandlersExtension extends SourcemapToolHandlersCommon {
-    async handleExtensionListInstalled(_args) {
-        const page = await this.collector.getActivePage();
-        const session = (await page.createCDPSession());
-        try {
-            const targets = await this.getExtensionTargets(session);
-            const result = targets.map((target) => ({
-                extensionId: target.extensionId,
-                name: target.name,
-                type: target.type,
-                url: target.url,
-            }));
-            return this.json(result);
-        }
-        catch (error) {
-            return this.fail('extension_list_installed', error);
-        }
-        finally {
-            await this.safeDetach(session);
-        }
-    }
-    async handleExtensionExecuteInContext(args) {
-        const extensionId = this.requiredStringArg(args.extensionId, 'extensionId');
-        const code = this.requiredStringArg(args.code, 'code');
-        const returnByValue = this.parseBooleanArg(args.returnByValue, true);
-        const page = await this.collector.getActivePage();
-        const session = (await page.createCDPSession());
-        let attachedSessionId = '';
-        try {
-            const targets = await this.getExtensionTargets(session, extensionId);
-            if (targets.length === 0) {
-                throw new Error(`No background target found for extension: ${extensionId}`);
-            }
-            const preferred = this.pickPreferredExtensionTarget(targets);
-            const attachResult = this.asRecord(await session.send('Target.attachToTarget', {
-                targetId: preferred.targetId,
-                flatten: true,
-            }));
-            attachedSessionId = this.requiredStringArg(attachResult.sessionId, 'sessionId');
-            const evaluation = await this.evaluateInAttachedTarget(session, attachedSessionId, code, returnByValue);
-            return this.json({
-                extensionId,
-                target: {
-                    type: preferred.type,
-                    url: preferred.url,
-                    name: preferred.name,
-                },
-                result: evaluation.result,
-                exceptionDetails: evaluation.exceptionDetails,
-            });
-        }
-        catch (error) {
-            return this.fail('extension_execute_in_context', error);
-        }
-        finally {
-            if (attachedSessionId) {
-                await this.trySend(session, 'Target.detachFromTarget', {
-                    sessionId: attachedSessionId,
-                });
-            }
-            await this.safeDetach(session);
-        }
-    }
-    async getExtensionTargets(session, expectedExtensionId) {
-        const response = this.asRecord(await session.send('Target.getTargets'));
-        const targetInfos = Array.isArray(response.targetInfos) ? response.targetInfos : [];
-        const allowedTypes = new Set(['service_worker', 'background_page']);
-        const result = [];
-        for (const item of targetInfos) {
-            const record = this.asRecord(item);
-            const targetId = this.asString(record.targetId);
-            const type = this.asString(record.type);
-            const url = this.asString(record.url);
-            if (!targetId || !type || !url) {
-                continue;
-            }
-            if (!allowedTypes.has(type)) {
-                continue;
-            }
-            const extensionId = this.extractExtensionId(url);
-            if (!extensionId) {
-                continue;
-            }
-            if (expectedExtensionId && extensionId !== expectedExtensionId) {
-                continue;
-            }
-            const title = this.asString(record.title) ?? '';
-            result.push({
-                targetId,
-                extensionId,
-                name: title || extensionId,
-                type: type,
-                url,
-            });
-        }
-        result.sort((left, right) => {
-            const leftScore = left.type === 'service_worker' ? 0 : 1;
-            const rightScore = right.type === 'service_worker' ? 0 : 1;
-            if (leftScore !== rightScore) {
-                return leftScore - rightScore;
-            }
-            return left.extensionId.localeCompare(right.extensionId);
-        });
-        return result;
-    }
-    pickPreferredExtensionTarget(targets) {
-        const serviceWorker = targets.find((target) => target.type === 'service_worker');
-        return serviceWorker ?? targets[0];
-    }
-    extractExtensionId(url) {
-        const match = url.match(/^chrome-extension:\/\/([a-p]{32})(?:\/|$)/i);
-        return match?.[1] ?? null;
-    }
-    async evaluateInAttachedTarget(session, sessionId, code, returnByValue) {
-        if (!session.on) {
-            throw new Error('CDP session does not support event listeners');
-        }
-        const commandId = Date.now() % 1_000_000_000;
-        const commandMessage = JSON.stringify({
-            id: commandId,
-            method: 'Runtime.evaluate',
-            params: {
-                expression: code,
-                returnByValue,
-                awaitPromise: true,
-            },
-        });
-        const responseMessage = await new Promise((resolvePromise, rejectPromise) => {
-            const timeout = setTimeout(() => {
-                cleanup();
-                rejectPromise(new Error('Runtime.evaluate timed out'));
-            }, 15_000);
-            const onMessage = (payload) => {
-                const record = this.asRecord(payload);
-                const incomingSessionId = this.asString(record.sessionId);
-                if (incomingSessionId !== sessionId) {
-                    return;
-                }
-                const rawMessage = this.asString(record.message);
-                if (!rawMessage) {
-                    return;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(rawMessage);
-                }
-                catch {
-                    return;
-                }
-                const parsedRecord = this.asRecord(parsed);
-                const incomingId = parsedRecord.id;
-                if (incomingId !== commandId) {
-                    return;
-                }
-                cleanup();
-                resolvePromise(parsedRecord);
-            };
-            const cleanup = () => {
-                clearTimeout(timeout);
-                session.off?.('Target.receivedMessageFromTarget', onMessage);
-            };
-            session.on?.('Target.receivedMessageFromTarget', onMessage);
-            session
-                .send('Target.sendMessageToTarget', {
-                sessionId,
-                message: commandMessage,
-            })
-                .catch((error) => {
-                cleanup();
-                rejectPromise(error);
-            });
-        });
-        const errorRecord = this.asRecord(responseMessage.error);
-        if (Object.keys(errorRecord).length > 0) {
-            const errorMessage = this.asString(errorRecord.message) ??
-                this.asString(errorRecord.data) ??
-                'Runtime.evaluate failed';
-            throw new Error(errorMessage);
-        }
-        const resultEnvelope = this.asRecord(responseMessage.result);
-        const resultValue = resultEnvelope.result !== undefined ? resultEnvelope.result : null;
-        const exceptionDetails = resultEnvelope.exceptionDetails !== undefined ? resultEnvelope.exceptionDetails : null;
-        return {
-            result: resultValue,
-            exceptionDetails,
-        };
-    }
-}

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-main.d.ts

@@ -1,7 +0,0 @@
-import type { TextToolResponse } from '../../domains/sourcemap/handlers.impl.sourcemap-parse-base.js';
-import { SourcemapToolHandlersExtension } from '../../domains/sourcemap/handlers.impl.sourcemap-extension.js';
-export declare class SourcemapToolHandlersMain extends SourcemapToolHandlersExtension {
-    handleSourcemapDiscover(args: Record<string, unknown>): Promise<TextToolResponse>;
-    handleSourcemapFetchAndParse(args: Record<string, unknown>): Promise<TextToolResponse>;
-    handleSourcemapReconstructTree(args: Record<string, unknown>): Promise<TextToolResponse>;
-}

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-main.js

@@ -1,156 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { resolveArtifactPath } from '../../../utils/artifacts.js';
-import { SourcemapToolHandlersExtension } from '../../domains/sourcemap/handlers.impl.sourcemap-extension.js';
-export class SourcemapToolHandlersMain extends SourcemapToolHandlersExtension {
-    async handleSourcemapDiscover(args) {
-        const includeInline = this.parseBooleanArg(args.includeInline, true);
-        const page = await this.collector.getActivePage();
-        const session = (await page.createCDPSession());
-        const scripts = new Map();
-        const onScriptParsed = (payload) => {
-            const record = this.asRecord(payload);
-            const scriptId = this.asString(record.scriptId);
-            if (!scriptId) {
-                return;
-            }
-            const scriptUrl = this.asString(record.url) ?? '';
-            const sourceMapUrlRaw = this.asString(record.sourceMapURL) ?? '';
-            const existing = scripts.get(scriptId);
-            const sourceMapUrlResolved = sourceMapUrlRaw
-                ? this.resolveSourceMapUrl(sourceMapUrlRaw, scriptUrl)
-                : (existing?.sourceMapUrl ?? '');
-            scripts.set(scriptId, {
-                scriptId,
-                scriptUrl: scriptUrl || existing?.scriptUrl || '',
-                sourceMapUrl: sourceMapUrlResolved,
-                isInline: sourceMapUrlResolved.startsWith('data:'),
-            });
-        };
-        try {
-            session.on?.('Debugger.scriptParsed', onScriptParsed);
-            await session.send('Debugger.enable');
-            await this.delay(250);
-            for (const item of scripts.values()) {
-                if (item.sourceMapUrl) {
-                    continue;
-                }
-                if (!item.scriptId || !item.scriptUrl) {
-                    continue;
-                }
-                try {
-                    const sourceResponse = this.asRecord(await session.send('Debugger.getScriptSource', {
-                        scriptId: item.scriptId,
-                    }));
-                    const scriptSource = this.asString(sourceResponse.scriptSource);
-                    if (!scriptSource) {
-                        continue;
-                    }
-                    const extracted = this.extractSourceMappingUrlFromScript(scriptSource);
-                    if (!extracted) {
-                        continue;
-                    }
-                    const resolvedSourceMap = this.resolveSourceMapUrl(extracted, item.scriptUrl);
-                    item.sourceMapUrl = resolvedSourceMap;
-                    item.isInline = resolvedSourceMap.startsWith('data:');
-                }
-                catch {
-                    continue;
-                }
-            }
-            const result = Array.from(scripts.values())
-                .filter((item) => item.sourceMapUrl.length > 0)
-                .filter((item) => includeInline || !item.isInline)
-                .toSorted((left, right) => {
-                const leftKey = `${left.scriptUrl}|${left.scriptId}`;
-                const rightKey = `${right.scriptUrl}|${right.scriptId}`;
-                return leftKey.localeCompare(rightKey);
-            })
-                .map((item) => ({
-                scriptUrl: item.scriptUrl,
-                sourceMapUrl: item.sourceMapUrl,
-                isInline: item.isInline,
-                scriptId: item.scriptId,
-            }));
-            return this.json(result);
-        }
-        catch (error) {
-            return this.fail('sourcemap_discover', error);
-        }
-        finally {
-            session.off?.('Debugger.scriptParsed', onScriptParsed);
-            await this.trySend(session, 'Debugger.disable');
-            await this.safeDetach(session);
-        }
-    }
-    async handleSourcemapFetchAndParse(args) {
-        try {
-            const sourceMapUrl = this.requiredStringArg(args.sourceMapUrl, 'sourceMapUrl');
-            const scriptUrl = this.optionalStringArg(args.scriptUrl);
-            const parsed = await this.parseSourceMap(sourceMapUrl, scriptUrl);
-            const responsePayload = {
-                sources: parsed.map.sources,
-                mappingsCount: parsed.mappingsCount,
-                segmentCount: parsed.segmentCount,
-            };
-            const hasSourcesContent = Array.isArray(parsed.map.sourcesContent);
-            if (hasSourcesContent) {
-                responsePayload.sourcesContent = parsed.map.sourcesContent;
-            }
-            return this.json(responsePayload);
-        }
-        catch (error) {
-            return this.fail('sourcemap_fetch_and_parse', error);
-        }
-    }
-    async handleSourcemapReconstructTree(args) {
-        try {
-            const sourceMapUrl = this.requiredStringArg(args.sourceMapUrl, 'sourceMapUrl');
-            const outputDir = this.optionalStringArg(args.outputDir);
-            const parsed = await this.parseSourceMap(sourceMapUrl, undefined);
-            const artifactTarget = this.safeTarget(parsed.resolvedUrl);
-            const artifactPath = await resolveArtifactPath({
-                category: 'reports',
-                toolName: 'sourcemap-tree',
-                target: artifactTarget,
-                ext: 'tmp',
-                ...(outputDir ? { customDir: outputDir } : {}),
-            });
-            const outputRoot = artifactPath.absolutePath.replace(/\.tmp$/i, '');
-            const outputRootDisplay = artifactPath.displayPath.replace(/\.tmp$/i, '');
-            await mkdir(outputRoot, { recursive: true });
-            const writtenFiles = [];
-            let skippedFiles = 0;
-            for (let index = 0; index < parsed.map.sources.length; index += 1) {
-                const rawSourcePath = parsed.map.sources[index] ?? '';
-                const sourcePath = this.combineSourceRoot(parsed.map.sourceRoot, rawSourcePath);
-                const relativePath = this.normalizeSourcePath(sourcePath, index);
-                const absolutePath = resolve(outputRoot, relativePath);
-                const sourceContent = parsed.map.sourcesContent && index < parsed.map.sourcesContent.length
-                    ? parsed.map.sourcesContent[index]
-                    : null;
-                const fileContent = typeof sourceContent === 'string'
-                    ? sourceContent
-                    : `/* source content missing in source map: ${sourcePath} */\n`;
-                try {
-                    await mkdir(dirname(absolutePath), { recursive: true });
-                    await writeFile(absolutePath, fileContent, 'utf-8');
-                    writtenFiles.push(relativePath);
-                }
-                catch {
-                    skippedFiles += 1;
-                }
-            }
-            return this.json({
-                outputDir: outputRootDisplay,
-                totalSources: parsed.map.sources.length,
-                writtenFiles: writtenFiles.length,
-                skippedFiles,
-                files: writtenFiles,
-            });
-        }
-        catch (error) {
-            return this.fail('sourcemap_reconstruct_tree', error);
-        }
-    }
-}

package/dist/src/server/domains/sourcemap/handlers.impl.sourcemap-parse-base.d.ts

@@ -1,73 +0,0 @@
-import type { CodeCollector } from '../../domains/shared/modules.js';
-export type JsonRecord = Record<string, unknown>;
-export interface TextToolResponse {
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-}
-export interface CdpSessionLike {
-    send(method: string, params?: JsonRecord): Promise<unknown>;
-    on?(event: string, listener: (params: unknown) => void): void;
-    off?(event: string, listener: (params: unknown) => void): void;
-    detach?(): Promise<void>;
-}
-export interface SourceMapV3 {
-    version: 3;
-    sources: string[];
-    sourcesContent?: Array<string | null>;
-    mappings: string;
-    names: string[];
-    sourceRoot?: string;
-}
-export interface DecodedMapping {
-    generatedLine: number;
-    generatedColumn: number;
-    sourceIndex?: number;
-    originalLine?: number;
-    originalColumn?: number;
-    nameIndex?: number;
-}
-export interface ParsedSourceMapResult {
-    resolvedUrl: string;
-    map: SourceMapV3;
-    mappings: DecodedMapping[];
-    mappingsCount: number;
-    segmentCount: number;
-}
-export interface DiscoverItem {
-    scriptUrl: string;
-    sourceMapUrl: string;
-    isInline: boolean;
-    scriptId: string;
-}
-export interface MutableDiscoverItem extends DiscoverItem {
-}
-export interface ExtensionTarget {
-    targetId: string;
-    extensionId: string;
-    name: string;
-    type: 'service_worker' | 'background_page';
-    url: string;
-}
-export declare class SourcemapToolHandlersParseBase {
-    protected collector: CodeCollector;
-    constructor(collector: CodeCollector);
-    protected parseSourceMap(sourceMapUrl: string, scriptUrl?: string): Promise<ParsedSourceMapResult>;
-    protected loadSourceMap(sourceMapUrl: string, scriptUrl?: string): Promise<{
-        resolvedUrl: string;
-        map: SourceMapV3;
-    }>;
-    protected normalizeSourceMap(value: unknown): SourceMapV3;
-    protected decodeMappings(mappings: string): DecodedMapping[];
-    protected decodeVlqSegment(segment: string): number[];
-    protected fromVlqSigned(value: number): number;
-    protected fetchSourceMapText(resolvedUrl: string): Promise<string>;
-    protected validateFetchUrl(url: string): void;
-    protected decodeDataUriJson(dataUri: string): string;
-    protected resolveSourceMapUrl(sourceMapUrl: string, scriptUrl: string): string;
-    protected extractSourceMappingUrlFromScript(scriptSource: string): string | null;
-    protected hasProtocol(value: string): boolean;
-    protected asRecord(value: unknown): JsonRecord;
-    protected asString(value: unknown): string | undefined;
-}