@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/search/ToolSearchEngineImpl.js

@@ -43,14 +43,14 @@ export class ToolSearchEngine {
     queryCache;
     bm25Scorer;
     intentBoost;
-    constructor(tools, domainOverrides, domainScoreMultipliers, toolScoreMultipliers) {
+    constructor(tools, domainOverrides, domainScoreMultipliers, toolScoreMultipliers, searchConfig) {
         const source = tools ?? allTools;
         this.domainOverrides = domainOverrides;
         this.domainScoreMultipliers = domainScoreMultipliers;
         this.toolScoreMultipliers = toolScoreMultipliers;
         this.docCount = source.length;
-        this.bm25Scorer = new BM25ScorerImpl();
-        this.intentBoost = new IntentBoostImpl();
+        this.bm25Scorer = new BM25ScorerImpl(searchConfig);
+        this.intentBoost = new IntentBoostImpl(searchConfig?.intentToolBoostRules);
         let totalLength = 0;
         for (let i = 0; i < source.length; i++) {
             const tool = source[i];
@@ -138,6 +138,47 @@ export class ToolSearchEngine {
         if (queryTokens.length === 0) {
             return [];
         }
+        const explicitToolMention = (() => {
+            const lower = query.toLowerCase();
+            const hasInvokeVerb = /(?:\b(?:call|use|run|invoke|execute)\b|调用|执行|使用|运行)/i.test(lower);
+            if (!hasInvokeVerb)
+                return null;
+            const wordCharIdent = /[a-z0-9_]/;
+            const wordCharPlain = /[a-z0-9]/;
+            const findDelimitedIndex = (haystack, needle, wordChar) => {
+                if (!needle)
+                    return -1;
+                let idx = haystack.indexOf(needle);
+                while (idx >= 0) {
+                    const before = idx > 0 ? haystack[idx - 1] : null;
+                    const after = idx + needle.length < haystack.length ? haystack[idx + needle.length] : null;
+                    const beforeOk = before === null || !wordChar.test(before);
+                    const afterOk = after === null || !wordChar.test(after);
+                    if (beforeOk && afterOk)
+                        return idx;
+                    idx = haystack.indexOf(needle, idx + 1);
+                }
+                return -1;
+            };
+            let bestTool = null;
+            let bestIdx = Number.POSITIVE_INFINITY;
+            for (const toolName of this.docNameIndex.keys()) {
+                let idx = findDelimitedIndex(lower, toolName, wordCharIdent);
+                if (idx < 0 && toolName.includes('_')) {
+                    idx = findDelimitedIndex(lower, toolName.replace(/_/g, '-'), wordCharPlain);
+                    if (idx < 0) {
+                        idx = findDelimitedIndex(lower, toolName.replace(/_/g, ' '), wordCharPlain);
+                    }
+                }
+                if (idx < 0)
+                    continue;
+                if (idx < bestIdx || (idx === bestIdx && toolName.length > (bestTool?.length ?? 0))) {
+                    bestTool = toolName;
+                    bestIdx = idx;
+                }
+            }
+            return bestTool;
+        })();
         const cacheKey = `${query}\0${topK}`;
         const cached = this.queryCache.get(cacheKey);
         if (cached) {
@@ -210,6 +251,20 @@ export class ToolSearchEngine {
         }
         this.applyAffinityExpansion(scores);
         this.applyDomainHubExpansion(scores);
+        if (explicitToolMention) {
+            const explicitIdx = this.docNameIndex.get(explicitToolMention);
+            if (explicitIdx !== undefined) {
+                let maxScore = 0;
+                for (let i = 0; i < this.docCount; i++) {
+                    const s = scores[i];
+                    if (s > maxScore) {
+                        maxScore = s;
+                    }
+                }
+                const bump = Math.max(1, maxScore + 1);
+                scores[explicitIdx] += bump;
+            }
+        }
         const active = activeToolNames ?? new Set();
         const candidates = [];
         for (let i = 0; i < this.docCount; i++) {

package/dist/src/server/workflows/WorkflowEngine.js

@@ -212,7 +212,7 @@ async function executeNode(ctx, node, executionContext, options) {
 }
 export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
     const runId = randomUUID();
-    const profile = options.profile ?? String(ctx.currentTier ?? 'workflow');
+    const profile = options.profile ?? String(ctx.baseTier ?? 'workflow');
     const startedAt = new Date().toISOString();
     const startedAtMs = Date.now();
     const metrics = [];

package/dist/src/types/config.d.ts

@@ -4,6 +4,7 @@ export interface Config {
     mcp: MCPConfig;
     cache: CacheConfig;
     performance: PerformanceConfig;
+    search: SearchConfig;
 }
 export interface LLMConfig {
     provider: 'openai' | 'anthropic';
@@ -46,3 +47,29 @@ export interface PerformanceConfig {
     maxConcurrentAnalysis: number;
     maxCodeSizeMB: number;
 }
+export interface SearchConfig {
+    queryCategoryProfiles: SearchQueryCategoryProfileConfig[];
+    cjkQueryAliases: SearchCjkQueryAliasConfig[];
+    intentToolBoostRules: SearchIntentToolBoostRuleConfig[];
+}
+export interface SearchQueryCategoryProfileConfig {
+    pattern: string;
+    flags?: string;
+    domainBoosts: Array<{
+        domain: string;
+        weight: number;
+    }>;
+}
+export interface SearchCjkQueryAliasConfig {
+    pattern: string;
+    flags?: string;
+    tokens: string[];
+}
+export interface SearchIntentToolBoostRuleConfig {
+    pattern: string;
+    flags?: string;
+    boosts: Array<{
+        tool: string;
+        bonus: number;
+    }>;
+}

package/dist/src/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { CodeLocation, Result } from './common.js';
-export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, } from './config.js';
+export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, SearchConfig, SearchQueryCategoryProfileConfig, SearchCjkQueryAliasConfig, SearchIntentToolBoostRuleConfig, } from './config.js';
 export type { BrowserContext } from './browser.js';
 export type { CollectCodeOptions, CodeFile, CollectCodeResult, DependencyGraph, DependencyNode, DependencyEdge, } from './collector.js';
 export type { ObfuscationType, Transformation, DeobfuscateOptions, DeobfuscateResult, DeobfuscateMappingRule, DeobfuscateSavedArtifact, DeobfuscateBundleModuleSummary, DeobfuscateBundleSummary, } from './deobfuscator.js';

package/dist/src/utils/config.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { config as dotenvConfig } from 'dotenv';
 import { z } from 'zod';
+import { DEFAULT_SEARCH_CONFIG } from '../config/search-defaults.js';
 const currentFilename = fileURLToPath(import.meta.url);
 const currentDirname = dirname(currentFilename);
 export const projectRoot = join(currentDirname, '..', '..');
@@ -49,6 +50,116 @@ const ConfigSchema = z.object({
     MAX_CONCURRENT_ANALYSIS: envInt(3).pipe(z.number().min(1).max(32)),
     MAX_CODE_SIZE_MB: envInt(10).pipe(z.number().min(1).max(500)),
 });
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseJsonArrayEnv(key) {
+    const raw = process.env[key];
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseSearchQueryCategoryProfiles() {
+    const parsed = parseJsonArrayEnv('SEARCH_QUERY_CATEGORY_PROFILES_JSON');
+    if (parsed === undefined) {
+        return undefined;
+    }
+    return parsed.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry.pattern !== 'string' || !Array.isArray(entry.domainBoosts)) {
+            return [];
+        }
+        const domainBoosts = entry.domainBoosts.flatMap((boost) => {
+            if (!isRecord(boost) || typeof boost.domain !== 'string' || typeof boost.weight !== 'number') {
+                return [];
+            }
+            return [{ domain: boost.domain, weight: boost.weight }];
+        });
+        return [{
+                pattern: entry.pattern,
+                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
+                domainBoosts,
+            }];
+    });
+}
+function parseCjkQueryAliases() {
+    const parsed = parseJsonArrayEnv('SEARCH_CJK_QUERY_ALIASES_JSON');
+    if (parsed === undefined) {
+        return undefined;
+    }
+    return parsed.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry.pattern !== 'string' || !Array.isArray(entry.tokens)) {
+            return [];
+        }
+        const tokens = entry.tokens.filter((token) => typeof token === 'string');
+        return [{
+                pattern: entry.pattern,
+                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
+                tokens,
+            }];
+    });
+}
+function parseIntentToolBoostRules() {
+    const parsed = parseJsonArrayEnv('SEARCH_INTENT_TOOL_BOOST_RULES_JSON');
+    if (parsed === undefined) {
+        return undefined;
+    }
+    return parsed.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry.pattern !== 'string' || !Array.isArray(entry.boosts)) {
+            return [];
+        }
+        const boosts = entry.boosts.flatMap((boost) => {
+            if (!isRecord(boost) || typeof boost.tool !== 'string' || typeof boost.bonus !== 'number') {
+                return [];
+            }
+            return [{ tool: boost.tool, bonus: boost.bonus }];
+        });
+        return [{
+                pattern: entry.pattern,
+                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
+                boosts,
+            }];
+    });
+}
+function cloneSearchConfig(search) {
+    return {
+        queryCategoryProfiles: search.queryCategoryProfiles.map((profile) => ({
+            pattern: profile.pattern,
+            flags: profile.flags,
+            domainBoosts: profile.domainBoosts.map((boost) => ({
+                domain: boost.domain,
+                weight: boost.weight,
+            })),
+        })),
+        cjkQueryAliases: search.cjkQueryAliases.map((alias) => ({
+            pattern: alias.pattern,
+            flags: alias.flags,
+            tokens: [...alias.tokens],
+        })),
+        intentToolBoostRules: search.intentToolBoostRules.map((rule) => ({
+            pattern: rule.pattern,
+            flags: rule.flags,
+            boosts: rule.boosts.map((boost) => ({
+                tool: boost.tool,
+                bonus: boost.bonus,
+            })),
+        })),
+    };
+}
+function buildSearchConfig() {
+    const defaults = cloneSearchConfig(DEFAULT_SEARCH_CONFIG);
+    return {
+        queryCategoryProfiles: parseSearchQueryCategoryProfiles() ?? defaults.queryCategoryProfiles,
+        cjkQueryAliases: parseCjkQueryAliases() ?? defaults.cjkQueryAliases,
+        intentToolBoostRules: parseIntentToolBoostRules() ?? defaults.intentToolBoostRules,
+    };
+}
 export function getConfig() {
     loadEnvIfNeeded();
     const parsed = ConfigSchema.safeParse(process.env);
@@ -65,6 +176,7 @@ export function getConfig() {
     const absoluteCacheDir = cacheDir.startsWith('/') || cacheDir.match(/^[A-Za-z]:/)
         ? cacheDir
         : join(projectRoot, cacheDir);
+    const search = buildSearchConfig();
     return {
         llm: {
             provider: (env.DEFAULT_LLM_PROVIDER || 'openai'),
@@ -97,6 +209,7 @@ export function getConfig() {
             maxConcurrentAnalysis: parsed.success ? env.MAX_CONCURRENT_ANALYSIS : parseInt(process.env.MAX_CONCURRENT_ANALYSIS || '3', 10),
             maxCodeSizeMB: parsed.success ? env.MAX_CODE_SIZE_MB : parseInt(process.env.MAX_CODE_SIZE_MB || '10', 10),
         },
+        search,
     };
 }
 export function validateConfig(config) {
@@ -113,5 +226,29 @@ export function validateConfig(config) {
     if (config.cache.ttl < 0) {
         errors.push('cache.ttl must be non-negative');
     }
+    for (const profile of config.search.queryCategoryProfiles) {
+        try {
+            void new RegExp(profile.pattern, profile.flags);
+        }
+        catch {
+            errors.push(`search.queryCategoryProfiles contains invalid regex: ${profile.pattern}`);
+        }
+    }
+    for (const alias of config.search.cjkQueryAliases) {
+        try {
+            void new RegExp(alias.pattern, alias.flags);
+        }
+        catch {
+            errors.push(`search.cjkQueryAliases contains invalid regex: ${alias.pattern}`);
+        }
+    }
+    for (const rule of config.search.intentToolBoostRules) {
+        try {
+            void new RegExp(rule.pattern, rule.flags);
+        }
+        catch {
+            errors.push(`search.intentToolBoostRules contains invalid regex: ${rule.pattern}`);
+        }
+    }
     return { valid: errors.length === 0, errors };
 }

package/dist/tests/cli/doctor.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const state = vi.hoisted(() => ({
+    runEnvironmentDoctor: vi.fn(),
+    formatEnvironmentDoctorReport: vi.fn(),
+}));
+vi.mock('@utils/environmentDoctor', () => ({
+    runEnvironmentDoctor: state.runEnvironmentDoctor,
+    formatEnvironmentDoctorReport: state.formatEnvironmentDoctorReport,
+}));
+describe('cli/doctor', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('runs the doctor with bridge health, prints the formatted report, and exits cleanly', async () => {
+        const report = {
+            success: true,
+            generatedAt: '2026-03-15T00:00:00.000Z',
+        };
+        state.runEnvironmentDoctor.mockResolvedValue(report);
+        state.formatEnvironmentDoctorReport.mockReturnValue('formatted report');
+        const stdoutWrite = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+        const exit = vi.spyOn(process, 'exit').mockImplementation((() => {
+            return undefined;
+        }));
+        await import('../../src/cli/doctor.js');
+        expect(state.runEnvironmentDoctor).toHaveBeenCalledWith({ includeBridgeHealth: true });
+        expect(state.formatEnvironmentDoctorReport).toHaveBeenCalledWith(report);
+        expect(stdoutWrite).toHaveBeenCalledWith('formatted report\n');
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});

package/dist/tests/constants.test.js

@@ -62,21 +62,6 @@ describe('constants env parsing', () => {
         expect((await loadConstants({ SEARCH_WORKFLOW_BOOST_TIERS: ' Workflow , FULL ' })).SEARCH_WORKFLOW_BOOST_TIERS).toEqual(new Set(['workflow', 'full']));
         expect((await loadConstants({ SEARCH_WORKFLOW_BOOST_TIERS: ' , , ' })).SEARCH_WORKFLOW_BOOST_TIERS).toEqual(new Set(['workflow', 'full']));
     });
-    it('parses optional json overrides with fallback semantics', async () => {
-        expect((await loadConstants({ SEARCH_INTENT_TOOL_BOOST_RULES_JSON: undefined }))
-            .SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE).toBeNull();
-        expect((await loadConstants({
-            SEARCH_INTENT_TOOL_BOOST_RULES_JSON: '[{"pattern":"captcha","flags":"i","boosts":[{"tool":"workflow","bonus":2}]}]',
-        })).SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE).toEqual([
-            {
-                pattern: 'captcha',
-                flags: 'i',
-                boosts: [{ tool: 'workflow', bonus: 2 }],
-            },
-        ]);
-        expect((await loadConstants({ SEARCH_INTENT_TOOL_BOOST_RULES_JSON: '{not-json' }))
-            .SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE).toBeNull();
-    });
     it('prefers the primary captcha solver url and trims both env variants', async () => {
         expect((await loadConstants({
             CAPTCHA_SOLVER_BASE_URL: ' https://vmoranv.github.io/jshookmcp/captcha-a ',

package/dist/tests/e2e/full-tool-e2e.test.js

@@ -36,8 +36,8 @@ const config = {
 };
 describe.skipIf(!TARGET_URL)('Full Tool E2E', { timeout: 300_000, sequential: true }, () => {
     const client = new MCPTestClient();
-    const ctx = { scriptId: null, breakpointId: null, requestId: null, hookId: null, objectId: null };
-    const alwaysSkip = buildSkipSet({ electronPath: config.electronPath, miniappPath: config.miniappPath });
+    const ctx = { scriptId: null, breakpointId: null, requestId: null, hookId: null, objectId: null, workflowId: null };
+    const alwaysSkip = buildSkipSet({ electronPath: config.electronPath, miniappPath: config.miniappPath, asarPath: config.asarPath });
     let overrides = {};
     let toolMap = new Map();
     beforeAll(async () => {
@@ -50,6 +50,7 @@ describe.skipIf(!TARGET_URL)('Full Tool E2E', { timeout: 300_000, sequential: tr
         const results = client.results;
         const pass = results.filter((r) => r.ok).length;
         const isErrorCount = results.filter((r) => r.isError).length;
+        const softFailCount = results.filter((r) => !r.ok && !r.isError).length;
         const report = {
             timestamp: new Date().toISOString(),
             targetUrl: TARGET_URL,
@@ -58,6 +59,7 @@ describe.skipIf(!TARGET_URL)('Full Tool E2E', { timeout: 300_000, sequential: tr
             pass,
             fail: results.length - pass,
             isErrorCount,
+            softFailCount,
             results,
         };
         const reportPath = join(ARTIFACT_DIR, 'e2e-full-report.json');
@@ -100,7 +102,7 @@ describe.skipIf(!TARGET_URL)('Full Tool E2E', { timeout: 300_000, sequential: tr
                         await new Promise((r) => setTimeout(r, 500));
                     }
                     const lastResult = client.results[client.results.length - 1];
-                    expect(lastResult?.isError, `${toolName} returned isError`).toBe(false);
+                    expect(lastResult?.ok, `${toolName} returned ok=false`).toBe(true);
                 });
             }
         });

package/dist/tests/e2e/helpers/mcp-client.js

@@ -36,7 +36,7 @@ export class MCPTestClient {
         const parsed = error ? null : parseContent(resp);
         const isError = isRecord(resp) && resp.isError === true;
         const softFail = !error && !isError && isRecord(parsed) && parsed.success === false;
-        const ok = !error && !isError;
+        const ok = !error && !isError && !softFail;
         let detail;
         if (error) {
             detail = error.message;

package/dist/tests/e2e/helpers/types.d.ts

@@ -10,6 +10,7 @@ export interface E2EContext {
     requestId: string | null;
     hookId: string | null;
     objectId: string | null;
+    workflowId: string | null;
 }
 export interface ToolResult {
     name: string;

package/dist/tests/e2e/overrides.js

@@ -124,7 +124,7 @@ export function getOverrides(ctx, config) {
         js_bundle_search: { pattern: 'fetch' },
         get_token_budget_stats: {}, get_cache_stats: {}, get_collection_stats: {},
         boost_profile: { profile: 'full' }, unboost_profile: {},
-        asar_extract: { inputPath: asarPath || '__placeholder__' },
+        asar_extract: asarPath ? { inputPath: asarPath } : {},
         electron_inspect_app: { appPath: electronPath || '__placeholder__' },
         miniapp_pkg_scan: { searchPath: miniappPath || '__placeholder__' },
         miniapp_pkg_unpack: { inputPath: miniappPath || '__placeholder__' },
@@ -144,6 +144,6 @@ export function getOverrides(ctx, config) {
         browse_extension_registry: {},
         batch_register: { tools: [] },
         list_extension_workflows: {},
-        run_extension_workflow: { workflowId: '__placeholder__' },
+        run_extension_workflow: { workflowId: ctx.workflowId ?? '__placeholder__' },
     };
 }

package/dist/tests/e2e/skip-list.d.ts

@@ -1,5 +1,6 @@
 export interface SkipListConfig {
     electronPath: string;
     miniappPath: string;
+    asarPath: string;
 }
 export declare function buildSkipSet(config: SkipListConfig): Set<string>;

package/dist/tests/e2e/skip-list.js

@@ -11,7 +11,9 @@ export function buildSkipSet(config) {
         'debugger_load_session',
         'install_extension',
         'captcha_vision_solve', 'widget_challenge_solve',
+        'run_extension_workflow',
         ...(!config.electronPath ? ['electron_attach', 'electron_inspect_app'] : []),
         ...(!config.miniappPath ? ['miniapp_pkg_analyze', 'miniapp_pkg_scan', 'miniapp_pkg_unpack'] : []),
+        ...(!config.asarPath ? ['asar_extract'] : []),
     ]);
 }

package/dist/tests/errors/PrerequisiteError.test.d.ts

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

package/dist/tests/errors/PrerequisiteError.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ToolError } from '../../src/errors/ToolError.js';
+import { PrerequisiteError } from '../../src/errors/PrerequisiteError.js';
+describe('PrerequisiteError', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('extends ToolError with the PREREQUISITE code and preserved message', () => {
+        const error = new PrerequisiteError('debugger must be enabled first');
+        expect(error).toBeInstanceOf(PrerequisiteError);
+        expect(error).toBeInstanceOf(ToolError);
+        expect(error).toBeInstanceOf(Error);
+        expect(error.name).toBe('PrerequisiteError');
+        expect(error.message).toBe('debugger must be enabled first');
+        expect(error.code).toBe('PREREQUISITE');
+        expect(error.toolName).toBeUndefined();
+        expect(error.details).toBeUndefined();
+    });
+});

package/dist/tests/errors/ToolError.test.d.ts

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

package/dist/tests/errors/ToolError.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ToolError, USER_CORRECTABLE_CODES } from '../../src/errors/ToolError.js';
+describe('ToolError', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('captures code, message, tool metadata, and cause', () => {
+        const cause = new Error('root-cause');
+        const error = new ToolError('RUNTIME', 'tool failed', {
+            toolName: 'page_evaluate',
+            details: { url: 'https://example.com' },
+            cause,
+        });
+        expect(error).toBeInstanceOf(ToolError);
+        expect(error).toBeInstanceOf(Error);
+        expect(error.name).toBe('ToolError');
+        expect(error.message).toBe('tool failed');
+        expect(error.code).toBe('RUNTIME');
+        expect(error.toolName).toBe('page_evaluate');
+        expect(error.details).toEqual({ url: 'https://example.com' });
+        expect(error.cause).toBe(cause);
+    });
+    it('tracks user-correctable error codes separately from fatal ones', () => {
+        expect(USER_CORRECTABLE_CODES.has('PREREQUISITE')).toBe(true);
+        expect(USER_CORRECTABLE_CODES.has('VALIDATION')).toBe(true);
+        expect(USER_CORRECTABLE_CODES.has('NOT_FOUND')).toBe(true);
+        expect(USER_CORRECTABLE_CODES.has('TIMEOUT')).toBe(false);
+        expect(USER_CORRECTABLE_CODES.has('RUNTIME')).toBe(false);
+    });
+});

package/dist/tests/modules/analyzer/CodeAnalyzerDataFlow.branches.test.d.ts

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