@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/ToolCallContextGuard.js

@@ -1,170 +0,0 @@
-import { logger } from '../utils/logger.js';
-const CONTEXT_SENSITIVE_PREFIXES = [
-    'page_',
-    'console_',
-    'debugger_',
-    'network_',
-    'dom_',
-    'stealth_',
-    'framework_',
-    'indexeddb_',
-    'js_heap_',
-    'script_',
-    'captcha_',
-    'ai_hook_',
-    'instrumentation_',
-    'hook_preset_',
-    'ws_',
-    'evidence_',
-];
-const MAX_CONSECUTIVE_REPEATS = 3;
-const REPEAT_GUARD_EXCLUDES = new Set([
-    'search_tools',
-    'route_tool',
-    'describe_tool',
-    'call_tool',
-    'activate_tools',
-    'deactivate_tools',
-    'activate_domain',
-]);
-const DOMAIN_ALTERNATIVES = new Map([
-    ['stealth', ['page_navigate', 'page_screenshot', 'stealth_verify']],
-    ['page', ['dom_get_structure', 'page_screenshot', 'console_get_logs']],
-    ['console', ['page_evaluate', 'page_screenshot']],
-    ['network', ['network_get_requests', 'page_navigate']],
-    ['captcha', ['captcha_wait', 'page_screenshot']],
-    ['ai_hook', ['manage_hooks', 'page_evaluate', 'ai_hook_inject']],
-    ['instrumentation', ['instrumentation_session_list', 'instrumentation_artifact_query']],
-    ['evidence', ['evidence_query_url', 'evidence_chain']],
-]);
-export class ToolCallContextGuard {
-    getProvider;
-    contextSensitiveCache = new Map();
-    lastToolName = null;
-    consecutiveCount = 0;
-    constructor(getProvider) {
-        this.getProvider = getProvider;
-    }
-    isContextSensitive(toolName) {
-        const cached = this.contextSensitiveCache.get(toolName);
-        if (cached !== undefined)
-            return cached;
-        const result = CONTEXT_SENSITIVE_PREFIXES.some((p) => toolName.startsWith(p));
-        this.contextSensitiveCache.set(toolName, result);
-        return result;
-    }
-    recordCall(toolName) {
-        if (REPEAT_GUARD_EXCLUDES.has(toolName)) {
-            return 0;
-        }
-        if (toolName === this.lastToolName) {
-            this.consecutiveCount++;
-        }
-        else {
-            this.lastToolName = toolName;
-            this.consecutiveCount = 1;
-        }
-        return this.consecutiveCount;
-    }
-    isRepeatLoop() {
-        return this.consecutiveCount >= MAX_CONSECUTIVE_REPEATS;
-    }
-    enrichResponse(toolName, response) {
-        if (this.isRepeatLoop() && !REPEAT_GUARD_EXCLUDES.has(toolName)) {
-            this.injectRepeatWarning(toolName, response);
-        }
-        if (!this.isContextSensitive(toolName))
-            return response;
-        if (response.isError)
-            return response;
-        const provider = this.getProvider();
-        if (!provider)
-            return response;
-        const meta = provider.getContextMeta();
-        if (!meta.pageId && meta.tabIndex === null)
-            return response;
-        const content = response.content;
-        if (!Array.isArray(content))
-            return response;
-        const firstText = content.find((c) => typeof c === 'object' &&
-            c !== null &&
-            c.type === 'text' &&
-            typeof c.text === 'string');
-        if (!firstText)
-            return response;
-        const raw = firstText.text;
-        const trimmedStart = raw.trimStart();
-        if (trimmedStart.startsWith('{') && trimmedStart.trimEnd().endsWith('}')) {
-            try {
-                const parsed = JSON.parse(raw);
-                if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                    if ('_tabContext' in parsed)
-                        return response;
-                    firstText.text = this.spliceTabContext(raw, meta);
-                    return response;
-                }
-            }
-            catch {
-                logger.debug(`[ContextGuard] Skipped non-JSON response enrichment for ${toolName}`);
-                return response;
-            }
-        }
-        return response;
-    }
-    spliceTabContext(raw, meta) {
-        const tabContext = {
-            url: meta.url,
-            title: meta.title,
-            tabIndex: meta.tabIndex,
-            pageId: meta.pageId,
-        };
-        if (/\n\}\s*$/.test(raw)) {
-            const prettyJson = JSON.stringify(tabContext, null, 2).replace(/\n/g, '\n  ');
-            return raw.replace(/\n\}\s*$/, `,\n  "_tabContext": ${prettyJson}\n}`);
-        }
-        const compactJson = JSON.stringify(tabContext);
-        if (/^\{\s*\}\s*$/.test(raw)) {
-            return raw.replace(/\{\s*\}\s*$/, `{"_tabContext":${compactJson}}`);
-        }
-        return raw.replace(/\}\s*$/, `,"_tabContext":${compactJson}}`);
-    }
-    injectRepeatWarning(toolName, response) {
-        const prefix = toolName.split('_')[0] ?? '';
-        const alternatives = DOMAIN_ALTERNATIVES.get(prefix) ?? ['page_navigate', 'page_screenshot'];
-        const suggestions = alternatives.filter((t) => t !== toolName);
-        const warning = {
-            detected: true,
-            consecutiveCount: this.consecutiveCount,
-            message: `⚠ You have called "${toolName}" ${this.consecutiveCount} times in a row. ` +
-                `This is likely a loop — consider what you actually need to do next.`,
-            suggestedTools: suggestions,
-            hint: suggestions.length > 0
-                ? `Try calling ${suggestions[0]} instead.`
-                : 'Re-evaluate your task objective before making another tool call.',
-        };
-        const content = response.content;
-        if (!Array.isArray(content))
-            return;
-        const firstText = content.find((c) => typeof c === 'object' &&
-            c !== null &&
-            c.type === 'text' &&
-            typeof c.text === 'string');
-        if (firstText) {
-            const raw = firstText.text;
-            try {
-                const parsed = JSON.parse(raw);
-                if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                    parsed._repeatWarning = warning;
-                    firstText.text = JSON.stringify(parsed, null, 2);
-                    return;
-                }
-            }
-            catch {
-            }
-        }
-        content.push({
-            type: 'text',
-            text: JSON.stringify({ _repeatWarning: warning }, null, 2),
-        });
-    }
-}

package/dist/src/server/ToolCatalog.d.ts

@@ -1,14 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { ToolProfileId } from './registry/contracts.js';
-export type ToolDomain = string;
-export type ToolProfile = ToolProfileId;
-export declare const allTools: Tool[];
-export declare const TIER_ORDER: readonly ["search", "workflow", "full"];
-export declare function getTierIndex(profile: ToolProfile): number;
-export declare function parseToolDomains(raw: string | undefined): string[] | null;
-export declare function getToolsByDomains(domains: string[]): Tool[];
-export declare function getToolsForProfile(profile: ToolProfile): Tool[];
-export declare function getToolDomain(toolName: string): string | null;
-export declare function getProfileDomains(profile: ToolProfile): string[];
-export declare function getToolMinimalTier(toolName: string): ToolProfile | null;
-export declare function getMinSatisfyingTier(toolNames: string[]): ToolProfile | null;

package/dist/src/server/ToolCatalog.js

@@ -1,114 +0,0 @@
-import { buildToolGroups, buildToolDomainMap, buildAllTools, buildProfileDomains, getAllDomains, getAllRegistrations, getRegistrationByName, } from './registry/index.js';
-let _toolGroups = null;
-let _toolDomainByName = null;
-let _profileDomains = null;
-let _allTools = null;
-function getToolGroups() {
-    if (!_toolGroups)
-        _toolGroups = buildToolGroups();
-    return _toolGroups;
-}
-function getToolDomainByName() {
-    if (!_toolDomainByName)
-        _toolDomainByName = buildToolDomainMap();
-    return _toolDomainByName;
-}
-function getProfileDomainsMap() {
-    if (!_profileDomains)
-        _profileDomains = buildProfileDomains();
-    return _profileDomains;
-}
-export const allTools = new Proxy([], {
-    get(_t, p) {
-        if (!_allTools)
-            _allTools = buildAllTools();
-        const real = _allTools;
-        const v = real[p];
-        return typeof v === 'function' ? v.bind(real) : v;
-    },
-});
-export const TIER_ORDER = ['search', 'workflow', 'full'];
-export function getTierIndex(profile) {
-    return TIER_ORDER.indexOf(profile);
-}
-function dedupeTools(tools) {
-    const map = new Map();
-    for (const tool of tools) {
-        map.set(tool.name, tool);
-    }
-    return Array.from(map.values());
-}
-export function parseToolDomains(raw) {
-    if (!raw?.trim()) {
-        return null;
-    }
-    const validDomains = getAllDomains();
-    const parsed = raw
-        .split(',')
-        .map((item) => item.trim().toLowerCase())
-        .filter(Boolean)
-        .filter((item) => validDomains.has(item));
-    return parsed.length > 0 ? Array.from(new Set(parsed)) : null;
-}
-export function getToolsByDomains(domains) {
-    const tools = domains.flatMap((domain) => getToolGroups()[domain] ?? []);
-    return dedupeTools(tools);
-}
-export function getToolsForProfile(profile) {
-    const domains = getProfileDomainsMap()[profile];
-    if (!domains)
-        return [];
-    const domainSet = new Set(domains);
-    const tools = [...getAllRegistrations()]
-        .filter((r) => {
-        if (!domainSet.has(r.domain))
-            return false;
-        if (r.profiles && !r.profiles.includes(profile))
-            return false;
-        return true;
-    })
-        .map((r) => r.tool);
-    return dedupeTools(tools);
-}
-export function getToolDomain(toolName) {
-    return getToolDomainByName().get(toolName) ?? null;
-}
-export function getProfileDomains(profile) {
-    return getProfileDomainsMap()[profile] ?? [];
-}
-export function getToolMinimalTier(toolName) {
-    const registration = getRegistrationByName(toolName);
-    if (registration?.profiles) {
-        for (const tier of TIER_ORDER) {
-            if (registration.profiles.includes(tier)) {
-                return tier;
-            }
-        }
-        return null;
-    }
-    const domain = getToolDomain(toolName);
-    if (!domain)
-        return null;
-    for (const tier of TIER_ORDER) {
-        const domains = getProfileDomains(tier);
-        if (domains.includes(domain)) {
-            return tier;
-        }
-    }
-    return null;
-}
-export function getMinSatisfyingTier(toolNames) {
-    if (toolNames.length === 0)
-        return null;
-    let maxTierIndex = -1;
-    for (const name of toolNames) {
-        const tier = getToolMinimalTier(name);
-        if (!tier)
-            continue;
-        const idx = getTierIndex(tier);
-        if (idx > maxTierIndex) {
-            maxTierIndex = idx;
-        }
-    }
-    return maxTierIndex >= 0 ? TIER_ORDER[maxTierIndex] : null;
-}

package/dist/src/server/ToolExecutionRouter.d.ts

@@ -1,10 +0,0 @@
-import type { ToolArgs, ToolHandler, ToolResponse } from './types.js';
-export declare class ToolExecutionRouter {
-    private readonly handlers;
-    constructor(handlers: Record<string, ToolHandler>);
-    has(toolName: string): boolean;
-    listToolNames(): string[];
-    addHandlers(handlers: Record<string, ToolHandler>): void;
-    removeHandler(toolName: string): void;
-    execute(toolName: string, args: ToolArgs): Promise<ToolResponse>;
-}

package/dist/src/server/ToolExecutionRouter.js

@@ -1,28 +0,0 @@
-import { ToolError } from '../errors/ToolError.js';
-export class ToolExecutionRouter {
-    handlers;
-    constructor(handlers) {
-        this.handlers = new Map(Object.entries(handlers));
-    }
-    has(toolName) {
-        return this.handlers.has(toolName);
-    }
-    listToolNames() {
-        return Array.from(this.handlers.keys());
-    }
-    addHandlers(handlers) {
-        for (const [name, handler] of Object.entries(handlers)) {
-            this.handlers.set(name, handler);
-        }
-    }
-    removeHandler(toolName) {
-        this.handlers.delete(toolName);
-    }
-    async execute(toolName, args) {
-        const handler = this.handlers.get(toolName);
-        if (!handler) {
-            throw new ToolError('NOT_FOUND', `Unknown tool: ${toolName}`, { toolName });
-        }
-        return handler(args);
-    }
-}

package/dist/src/server/ToolHandlerMap.d.ts

@@ -1,5 +0,0 @@
-import type { ToolHandler } from './types.js';
-import type { ToolHandlerDeps } from './registry/contracts.js';
-export type ToolHandlerMapDependencies = ToolHandlerDeps;
-export declare function getHandledToolNames(): ReadonlySet<string>;
-export declare function createToolHandlerMap(deps: ToolHandlerDeps, selectedToolNames?: ReadonlySet<string>): Record<string, ToolHandler>;

package/dist/src/server/ToolHandlerMap.js

@@ -1,7 +0,0 @@
-import { buildHandlerMapFromRegistry, getAllToolNames } from './registry/index.js';
-export function getHandledToolNames() {
-    return getAllToolNames();
-}
-export function createToolHandlerMap(deps, selectedToolNames) {
-    return buildHandlerMapFromRegistry(deps, selectedToolNames);
-}

package/dist/src/server/ToolRouter.d.ts

@@ -1,64 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { type ToolSearchEngine } from './ToolSearch.js';
-import type { WorkflowRule, RoutedWorkflowMatch } from './ToolRouter.intent.js';
-import type { RoutingState } from './ToolRouter.probe.js';
-export type { WorkflowRule, RoutedWorkflowMatch };
-export type { RoutingState };
-import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
-export interface RouterRequest {
-    task: string;
-    context?: {
-        preferredDomain?: string;
-        autoActivate?: boolean;
-        maxRecommendations?: number;
-    };
-}
-export interface RouterResponse {
-    recommendations: Array<{
-        name: string;
-        domain: string | null;
-        description: string;
-        inputSchema: Tool['inputSchema'];
-        score: number;
-        isActive: boolean;
-        activationCommand?: string;
-        callCommand?: string;
-        prerequisites?: Array<{
-            condition: string;
-            satisfied: boolean;
-            fix: string;
-        }>;
-    }>;
-    nextActions: Array<{
-        step: number;
-        action: 'activate' | 'call';
-        toolName?: string;
-        command: string;
-        exampleArgs?: Record<string, unknown>;
-        description: string;
-    }>;
-    workflowHint?: string;
-    routeMatch?: {
-        kind: WorkflowRouteMetadata['kind'];
-        id: string;
-        name: string;
-        description: string;
-        confidence: number;
-        matchedPattern: string;
-        requiredDomains: string[];
-        steps: Array<{
-            id: string;
-            toolName: string;
-            domain: string | null;
-            description: string;
-            prerequisites: string[];
-            parallel?: boolean;
-            isActive: boolean;
-        }>;
-    };
-    autoActivated?: boolean;
-    activatedNames?: string[];
-    callToolHint?: string;
-}
-export declare function routeToolRequest(request: RouterRequest, ctx: import('./MCPServer.context.js').MCPServerContext, searchEngine: ToolSearchEngine): Promise<RouterResponse>;
-export { buildCallToolCommand, describeTool, generateExampleArgs, } from './ToolRouter.renderer.js';

package/dist/src/server/ToolRouter.intent.d.ts

@@ -1,26 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { WorkflowRouteMetadata } from './workflows/WorkflowContract.js';
-export interface WorkflowRule {
-    patterns: RegExp[];
-    domain: string;
-    priority: number;
-    tools: string[];
-    hint: string;
-}
-export interface RoutedWorkflowMatch {
-    workflow: {
-        id: string;
-        name: string;
-        description: string;
-        route: WorkflowRouteMetadata;
-    };
-    confidence: number;
-    matchedPattern: string;
-}
-export declare const BROWSER_OR_NETWORK_TASK_PATTERN: RegExp;
-export declare const MAINTENANCE_TASK_PATTERN: RegExp;
-export declare function getEffectiveWorkflowRules(): WorkflowRule[];
-export declare function detectWorkflowIntent(query: string): WorkflowRule | null;
-export declare function matchWorkflowRoute(query: string, ctx: MCPServerContext): RoutedWorkflowMatch | null;
-export declare function isBrowserOrNetworkTask(task: string, workflow: WorkflowRule | null): boolean;
-export declare function isMaintenanceTask(task: string): boolean;

package/dist/src/server/ToolRouter.intent.js

@@ -1,77 +0,0 @@
-import { getAllManifests } from './registry/index.js';
-export const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
-export const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
-let _cachedWorkflowRules = null;
-export function getEffectiveWorkflowRules() {
-    if (_cachedWorkflowRules)
-        return _cachedWorkflowRules;
-    const rules = [];
-    for (const m of getAllManifests()) {
-        if (m.workflowRule) {
-            rules.push({
-                patterns: [...m.workflowRule.patterns],
-                domain: m.domain,
-                priority: m.workflowRule.priority,
-                tools: [...m.workflowRule.tools],
-                hint: m.workflowRule.hint,
-            });
-        }
-    }
-    _cachedWorkflowRules = [...rules].toSorted((a, b) => b.priority - a.priority);
-    return _cachedWorkflowRules;
-}
-export function detectWorkflowIntent(query) {
-    const matches = [];
-    for (const rule of getEffectiveWorkflowRules()) {
-        for (const pattern of rule.patterns) {
-            if (pattern.test(query)) {
-                matches.push(rule);
-                break;
-            }
-        }
-    }
-    if (matches.length === 0)
-        return null;
-    matches.sort((a, b) => b.priority - a.priority);
-    return matches[0];
-}
-export function matchWorkflowRoute(query, ctx) {
-    let bestMatch = null;
-    for (const [workflowId, runtimeRecord] of ctx.extensionWorkflowRuntimeById.entries()) {
-        const route = runtimeRecord.route ?? runtimeRecord.workflow.route;
-        if (!route) {
-            continue;
-        }
-        const descriptor = ctx.extensionWorkflowsById.get(workflowId);
-        const name = descriptor?.displayName ?? runtimeRecord.workflow.displayName;
-        const description = descriptor?.description ?? runtimeRecord.workflow.description ?? 'Workflow route';
-        for (const pattern of route.triggerPatterns) {
-            if (!pattern.test(query)) {
-                continue;
-            }
-            const confidence = route.priority / 100;
-            if (!bestMatch || confidence > bestMatch.confidence) {
-                bestMatch = {
-                    workflow: {
-                        id: workflowId,
-                        name,
-                        description,
-                        route,
-                    },
-                    confidence,
-                    matchedPattern: pattern.source,
-                };
-            }
-            break;
-        }
-    }
-    return bestMatch;
-}
-export function isBrowserOrNetworkTask(task, workflow) {
-    return (workflow?.domain === 'browser' ||
-        workflow?.domain === 'network' ||
-        BROWSER_OR_NETWORK_TASK_PATTERN.test(task));
-}
-export function isMaintenanceTask(task) {
-    return MAINTENANCE_TASK_PATTERN.test(task);
-}