@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/domains/workflow/handlers.impl.workflow-api.js

@@ -1,6 +1,7 @@
 import { logger } from '../../../utils/logger.js';
 import { isSsrfTarget } from '../../domains/network/replay.js';
 import { WorkflowHandlersBase } from '../../domains/workflow/handlers.impl.workflow-base.js';
+import { argString, argStringRequired, argBool, argNumber, argObject } from '../../domains/shared/parse-args.js';
 function isReportAuthFinding(value) {
     if (!value || typeof value !== 'object') {
         return false;
@@ -84,16 +85,14 @@ export class WorkflowHandlersApi extends WorkflowHandlersBase {
                     return [];
                 } })()
                 : [];
-        const method = (args.method ?? 'GET').toUpperCase();
-        const extraHeaders = args.headers ?? {};
-        const bodyTemplate = args.bodyTemplate ?? null;
+        const method = (argString(args, 'method') ?? 'GET').toUpperCase();
+        const extraHeaders = (argObject(args, 'headers') ?? {});
+        const bodyTemplate = argString(args, 'bodyTemplate') ?? null;
         const includeBodyStatuses = Array.isArray(args.includeBodyStatuses)
             ? args.includeBodyStatuses.filter((v) => typeof v === 'number')
             : [200, 201, 204];
-        const maxBodySnippetLength = typeof args.maxBodySnippetLength === 'number'
-            ? Math.max(0, Math.min(args.maxBodySnippetLength, 10000))
-            : 500;
-        const autoInjectAuth = typeof args.autoInjectAuth === 'boolean' ? args.autoInjectAuth : true;
+        const maxBodySnippetLength = Math.max(0, Math.min(argNumber(args, 'maxBodySnippetLength', 500), 10000));
+        const autoInjectAuth = argBool(args, 'autoInjectAuth', true);
         if (!paths || paths.length === 0) {
             return {
                 content: [{
@@ -102,57 +101,57 @@ export class WorkflowHandlersApi extends WorkflowHandlersBase {
                     }],
             };
         }
-        const probeCode = `(async function() {
-  var baseUrl = ${JSON.stringify(baseUrl)};
-  var paths = ${JSON.stringify(paths)};
-  var method = ${JSON.stringify(method)};
-  var extraHeaders = ${JSON.stringify(extraHeaders)};
-  var includeBodyStatuses = ${JSON.stringify(includeBodyStatuses)};
-  var maxSnippetLen = ${JSON.stringify(maxBodySnippetLength)};
-  var autoInjectAuth = ${JSON.stringify(autoInjectAuth)};
-  var bodyTemplate = ${JSON.stringify(bodyTemplate)};
-
-  var headers = Object.assign({'Content-Type':'application/json'}, extraHeaders);
-  if (autoInjectAuth) {
-    var token = localStorage.getItem('token') || localStorage.getItem('active_token') || localStorage.getItem('access_token');
-    if (token) headers['Authorization'] = 'Bearer ' + token;
-  }
-
-  var results = {};
-  async function probePath(path) {
-    try {
-      var opts = {method: method, headers: headers};
-      if (bodyTemplate && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
-        opts.body = bodyTemplate;
-      }
-      var resp = await fetch(baseUrl + path, opts);
-      var ct = resp.headers.get('content-type') || '';
-      var snippet = null;
-      if (includeBodyStatuses.indexOf(resp.status) !== -1) {
-        var text = await resp.text();
-        if (!ct.includes('text/html') && !ct.includes('application/xml')) {
-          snippet = text.length > maxSnippetLen ? text.slice(0, maxSnippetLen) + '...[truncated]' : text;
-        } else {
-          snippet = '[HTML/XML response suppressed]';
-        }
-      }
-      return [path, {status: resp.status, contentType: ct.split(';')[0].trim(), snippet: snippet}];
-    } catch(e) {
-      return [path, {status: -1, error: e instanceof Error ? e.message : String(e)}];
-    }
-  }
-
-  var nextIndex = 0;
-  var maxConcurrency = Math.min(paths.length, 6);
-  await Promise.all(Array.from({ length: maxConcurrency }, async function() {
-    while (nextIndex < paths.length) {
-      var currentIndex = nextIndex++;
-      var currentPath = paths[currentIndex];
-      var entry = await probePath(currentPath);
-      results[entry[0]] = entry[1];
-    }
-  }));
-  return {probed: paths.length, method: method, baseUrl: baseUrl, results: results};
+        const probeCode = `(async function() {
+  var baseUrl = ${JSON.stringify(baseUrl)};
+  var paths = ${JSON.stringify(paths)};
+  var method = ${JSON.stringify(method)};
+  var extraHeaders = ${JSON.stringify(extraHeaders)};
+  var includeBodyStatuses = ${JSON.stringify(includeBodyStatuses)};
+  var maxSnippetLen = ${JSON.stringify(maxBodySnippetLength)};
+  var autoInjectAuth = ${JSON.stringify(autoInjectAuth)};
+  var bodyTemplate = ${JSON.stringify(bodyTemplate)};
+
+  var headers = Object.assign({'Content-Type':'application/json'}, extraHeaders);
+  if (autoInjectAuth) {
+    var token = localStorage.getItem('token') || localStorage.getItem('active_token') || localStorage.getItem('access_token');
+    if (token) headers['Authorization'] = 'Bearer ' + token;
+  }
+
+  var results = {};
+  async function probePath(path) {
+    try {
+      var opts = {method: method, headers: headers};
+      if (bodyTemplate && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        opts.body = bodyTemplate;
+      }
+      var resp = await fetch(baseUrl + path, opts);
+      var ct = resp.headers.get('content-type') || '';
+      var snippet = null;
+      if (includeBodyStatuses.indexOf(resp.status) !== -1) {
+        var text = await resp.text();
+        if (!ct.includes('text/html') && !ct.includes('application/xml')) {
+          snippet = text.length > maxSnippetLen ? text.slice(0, maxSnippetLen) + '...[truncated]' : text;
+        } else {
+          snippet = '[HTML/XML response suppressed]';
+        }
+      }
+      return [path, {status: resp.status, contentType: ct.split(';')[0].trim(), snippet: snippet}];
+    } catch(e) {
+      return [path, {status: -1, error: e instanceof Error ? e.message : String(e)}];
+    }
+  }
+
+  var nextIndex = 0;
+  var maxConcurrency = Math.min(paths.length, 6);
+  await Promise.all(Array.from({ length: maxConcurrency }, async function() {
+    while (nextIndex < paths.length) {
+      var currentIndex = nextIndex++;
+      var currentPath = paths[currentIndex];
+      var entry = await probePath(currentPath);
+      results[entry[0]] = entry[1];
+    }
+  }));
+  return {probed: paths.length, method: method, baseUrl: baseUrl, results: results};
 })()`;
         try {
             const result = await this.deps.browserHandlers.handlePageEvaluate({ code: probeCode });
@@ -172,19 +171,19 @@ export class WorkflowHandlersApi extends WorkflowHandlersBase {
         }
     }
     async handleWebApiCaptureSession(args) {
-        const url = args.url;
-        const waitUntil = args.waitUntil ?? 'domcontentloaded';
+        const url = argStringRequired(args, 'url');
+        const waitUntil = argString(args, 'waitUntil', 'domcontentloaded');
         const actions = parseCaptureActions(args.actions);
-        const exportHar = args.exportHar ?? true;
-        const exportReport = args.exportReport ?? true;
+        const exportHar = argBool(args, 'exportHar', true);
+        const exportReport = argBool(args, 'exportReport', true);
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
         const harOutputPath = exportHar
-            ? this.normalizeOutputPath(args.harOutputPath, `artifacts/har/jshook-capture-${timestamp}.har`, 'artifacts/har')
+            ? this.normalizeOutputPath(argString(args, 'harOutputPath'), `artifacts/har/jshook-capture-${timestamp}.har`, 'artifacts/har')
             : undefined;
         const reportOutputPath = exportReport
-            ? this.normalizeOutputPath(args.reportOutputPath, `artifacts/reports/web-api-capture-${timestamp}.md`, 'artifacts/reports')
+            ? this.normalizeOutputPath(argString(args, 'reportOutputPath'), `artifacts/reports/web-api-capture-${timestamp}.md`, 'artifacts/reports')
             : undefined;
-        const waitAfterActionsMs = args.waitAfterActionsMs ?? 1500;
+        const waitAfterActionsMs = argNumber(args, 'waitAfterActionsMs', 1500);
         const steps = [];
         const warnings = [];
         try {

package/dist/src/server/domains/workflow/handlers.impl.workflow-base.js

@@ -4,6 +4,7 @@ import { mkdir, writeFile, realpath } from 'node:fs/promises';
 import { dirname, basename, resolve, relative, isAbsolute } from 'node:path';
 import { getProjectRoot } from '../../../utils/outputPaths.js';
 import { executeExtensionWorkflow } from '../../workflows/WorkflowEngine.js';
+import { argNumber, argObject } from '../../domains/shared/parse-args.js';
 export class WorkflowHandlersBase {
     deps;
     scriptRegistry = new Map();
@@ -356,8 +357,8 @@ export class WorkflowHandlersBase {
         }
         const profile = this.getOptionalString(args.profile);
         const config = this.getOptionalRecord(args.config);
-        const nodeInputOverrides = this.getOptionalRecord(args.nodeInputOverrides);
-        const timeoutMs = typeof args.timeoutMs === 'number' ? args.timeoutMs : undefined;
+        const nodeInputOverrides = argObject(args, 'nodeInputOverrides');
+        const timeoutMs = argNumber(args, 'timeoutMs');
         try {
             const result = await executeExtensionWorkflow(ctx, runtimeRecord.workflow, {
                 profile,

package/dist/src/server/domains/workflow/handlers.impl.workflow-batch.js

@@ -1,24 +1,28 @@
 import { logger } from '../../../utils/logger.js';
 import { WorkflowHandlersAccountBundle } from '../../domains/workflow/handlers.impl.workflow-account-bundle.js';
 import { WORKFLOW_BATCH_MAX_RETRIES, WORKFLOW_BATCH_MAX_BACKOFF_MS, WORKFLOW_BATCH_MAX_TIMEOUT_MS, WORKFLOW_BATCH_RETRY_BACKOFF_MS, WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS, } from '../../../constants.js';
-const MAX_ACCOUNTS = 50;
-const MAX_CONCURRENCY = 1;
+import { argNumber, argString, argObject, argStringArray } from '../../domains/shared/parse-args.js';
+var WorkflowBatchLimit;
+(function (WorkflowBatchLimit) {
+    WorkflowBatchLimit[WorkflowBatchLimit["MAX_ACCOUNTS"] = 50] = "MAX_ACCOUNTS";
+    WorkflowBatchLimit[WorkflowBatchLimit["MAX_CONCURRENCY"] = 1] = "MAX_CONCURRENCY";
+})(WorkflowBatchLimit || (WorkflowBatchLimit = {}));
 const MAX_RETRIES = WORKFLOW_BATCH_MAX_RETRIES;
 const MAX_BACKOFF_MS = WORKFLOW_BATCH_MAX_BACKOFF_MS;
 const MAX_TIMEOUT_MS = WORKFLOW_BATCH_MAX_TIMEOUT_MS;
 export class WorkflowHandlersBatch extends WorkflowHandlersAccountBundle {
     async handleBatchRegister(args) {
-        const registerUrl = args.registerUrl;
+        const registerUrl = argString(args, 'registerUrl', '');
         const rawAccounts = args.accounts;
         let accounts = Array.isArray(rawAccounts) ? rawAccounts : [];
-        if (accounts.length > MAX_ACCOUNTS) {
-            accounts = accounts.slice(0, MAX_ACCOUNTS);
+        if (accounts.length > WorkflowBatchLimit.MAX_ACCOUNTS) {
+            accounts = accounts.slice(0, WorkflowBatchLimit.MAX_ACCOUNTS);
         }
-        const maxConcurrency = Math.min(Math.max(1, args.maxConcurrency ?? 1), MAX_CONCURRENCY);
-        const maxRetries = Math.min(Math.max(0, args.maxRetries ?? 1), MAX_RETRIES);
-        const retryBackoffMs = Math.max(0, args.retryBackoffMs ?? WORKFLOW_BATCH_RETRY_BACKOFF_MS);
-        const timeoutPerAccountMs = Math.min(Math.max(5000, args.timeoutPerAccountMs ?? WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS), MAX_TIMEOUT_MS);
-        const defaultSubmitSelector = args.submitSelector ?? "button[type='submit']";
+        const maxConcurrency = Math.min(Math.max(1, argNumber(args, 'maxConcurrency', 1)), WorkflowBatchLimit.MAX_CONCURRENCY);
+        const maxRetries = Math.min(Math.max(0, argNumber(args, 'maxRetries', 1)), MAX_RETRIES);
+        const retryBackoffMs = Math.max(0, argNumber(args, 'retryBackoffMs', WORKFLOW_BATCH_RETRY_BACKOFF_MS));
+        const timeoutPerAccountMs = Math.min(Math.max(5000, argNumber(args, 'timeoutPerAccountMs', WORKFLOW_BATCH_TIMEOUT_PER_ACCOUNT_MS)), MAX_TIMEOUT_MS);
+        const defaultSubmitSelector = argString(args, 'submitSelector', "button[type='submit']");
         if (!registerUrl || accounts.length === 0) {
             return this.jsonTextResult({
                 success: false,
@@ -28,7 +32,7 @@ export class WorkflowHandlersBatch extends WorkflowHandlersAccountBundle {
         const succeeded = new Set();
         const results = [];
         const getIdempotentKey = (acct, globalIdx) => {
-            const fields = acct.fields;
+            const fields = argObject(acct, 'fields');
             if (!fields)
                 return `account-${globalIdx}`;
             return fields.email ?? fields.username ?? fields.name ?? Object.values(fields)[0] ?? `account-${globalIdx}`;
@@ -53,15 +57,12 @@ export class WorkflowHandlersBatch extends WorkflowHandlersAccountBundle {
                     });
                     return;
                 }
-                const acctFields = acct.fields ?? {};
-                const acctSubmitSelector = acct.submitSelector ?? defaultSubmitSelector;
-                const acctEmailProviderUrl = acct.emailProviderUrl;
-                const acctEmailSelector = acct.emailSelector;
-                const acctVerificationLinkPattern = acct.verificationLinkPattern;
-                const rawCheckboxSelectors = acct.checkboxSelectors;
-                const acctCheckboxSelectors = Array.isArray(rawCheckboxSelectors)
-                    ? rawCheckboxSelectors
-                    : [];
+                const acctFields = (argObject(acct, 'fields') ?? {});
+                const acctSubmitSelector = argString(acct, 'submitSelector', defaultSubmitSelector);
+                const acctEmailProviderUrl = argString(acct, 'emailProviderUrl');
+                const acctEmailSelector = argString(acct, 'emailSelector');
+                const acctVerificationLinkPattern = argString(acct, 'verificationLinkPattern');
+                const acctCheckboxSelectors = argStringArray(acct, 'checkboxSelectors');
                 let lastError = null;
                 let attempts = 0;
                 for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -136,8 +137,8 @@ export class WorkflowHandlersBatch extends WorkflowHandlersAccountBundle {
                 succeeded: successCount,
                 failed: failCount,
                 skipped: results.filter(r => r.result?.skipped).length,
-                truncated: Array.isArray(rawAccounts) && rawAccounts.length > MAX_ACCOUNTS
-                    ? { original: rawAccounts.length, limit: MAX_ACCOUNTS }
+                truncated: Array.isArray(rawAccounts) && rawAccounts.length > WorkflowBatchLimit.MAX_ACCOUNTS
+                    ? { original: rawAccounts.length, limit: WorkflowBatchLimit.MAX_ACCOUNTS }
                     : undefined,
             },
             results,

package/dist/src/server/domains/workflow/handlers.js

@@ -1 +1 @@
-export { WorkflowHandlers } from '../../domains/workflow/handlers.impl.js';
+export { WorkflowHandlers } from '../../domains/workflow/handlers.impl.core.js';

package/dist/src/server/domains/workflow/manifest.d.ts

@@ -1,7 +1,57 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext } from '../../domains/shared/registry.js';
 import { WorkflowHandlers } from '../../domains/workflow/index.js';
-declare const DOMAIN: "workflow";
-declare const DEP_KEY: "workflowHandlers";
 type H = WorkflowHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "workflow";
+    depKey: "workflowHandlers";
+    profiles: ("workflow" | "full")[];
+    ensure: typeof ensure;
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "workflow";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;

package/dist/src/server/registry/contracts.d.ts

@@ -9,6 +9,7 @@ export interface ToolRegistration {
     readonly tool: Tool;
     readonly domain: string;
     readonly bind: (deps: ToolHandlerDeps) => (args: ToolArgs) => Promise<unknown>;
+    readonly profiles?: readonly ToolProfileId[];
 }
 export interface DomainManifest<TDepKey extends string = string, THandler = unknown, TDomain extends string = string> {
     readonly kind: 'domain-manifest';

package/dist/src/server/search/BM25Scorer.d.ts

@@ -1,12 +1,22 @@
+import type { SearchCjkQueryAliasConfig, SearchConfig, SearchQueryCategoryProfileConfig } from '../../types/config.js';
 export interface QueryCategoryProfile {
     pattern: RegExp;
     domainBoosts: ReadonlyMap<string, number>;
 }
-export declare const QUERY_CATEGORY_PROFILES: ReadonlyArray<QueryCategoryProfile>;
+interface CjkQueryAliasRule {
+    pattern: RegExp;
+    tokens: readonly string[];
+}
 export declare class BM25ScorerImpl {
+    private readonly queryCategoryProfiles;
+    private readonly cjkQueryAliases;
+    constructor(searchConfig?: Pick<SearchConfig, 'queryCategoryProfiles' | 'cjkQueryAliases'>);
+    static compileQueryCategoryProfiles(config: SearchQueryCategoryProfileConfig[]): ReadonlyArray<QueryCategoryProfile>;
+    static compileCjkQueryAliasRules(config: SearchCjkQueryAliasConfig[]): ReadonlyArray<CjkQueryAliasRule>;
     detectQueryCategoryBoosts(query: string): Map<string, number>;
     expandCjkAliasTokens(text: string): string[];
     tokenise(text: string): string[];
     getK1(): number;
     getB(): number;
 }
+export {};

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

@@ -1,66 +1,63 @@
+import { DEFAULT_SEARCH_CONFIG } from '../../config/search-defaults.js';
 const K1 = 1.5;
 const B = 0.3;
-export const QUERY_CATEGORY_PROFILES = [
-    {
-        pattern: /(?:security|vuln|xss|injection|csrf|exploit|attack|prototype\s*pollution|漏洞|安全|注入|攻击)/i,
-        domainBoosts: new Map([['security', 1.6], ['analysis', 1.2]]),
-    },
-    {
-        pattern: /(?:debug|breakpoint|pause|step\s*over|step\s*into|stack\s*trace|断点|调试|单步)/i,
-        domainBoosts: new Map([['debugger', 1.6], ['runtime', 1.2]]),
-    },
-    {
-        pattern: /(?:network|request|response|header|cookie|fetch|xhr|网络|请求|抓包)/i,
-        domainBoosts: new Map([['network', 1.6], ['browser', 1.1]]),
-    },
-    {
-        pattern: /(?:transform|deobfuscate|beautify|minify|decode|encode|解密|混淆|反混淆|转换)/i,
-        domainBoosts: new Map([['transform', 1.6], ['analysis', 1.2]]),
-    },
-    {
-        pattern: /(?:memory|heap|dump|scan|inject|内存|堆|扫描)/i,
-        domainBoosts: new Map([['memory', 1.6], ['native', 1.2]]),
-    },
-    {
-        pattern: /(?:wasm|webassembly)/i,
-        domainBoosts: new Map([['wasm', 1.6]]),
-    },
-    {
-        pattern: /(?:browser|page|tab|navigate|click|screenshot|浏览器|页面|标签)/i,
-        domainBoosts: new Map([['browser', 1.4]]),
-    },
-    {
-        pattern: /(?:captcha|人机验证|验证码|图形验证)/i,
-        domainBoosts: new Map([['captcha', 1.6], ['browser', 1.1]]),
-    },
-];
-const CJK_QUERY_ALIASES = [
-    { pattern: /工作流|流程编排|流程自动化|编排/, tokens: ['workflow', 'flow', 'orchestration'] },
-    { pattern: /抓包|抓取|采集|捕获/, tokens: ['capture', 'sniff', 'collect'] },
-    { pattern: /接口|端点/, tokens: ['api', 'endpoint', 'request'] },
-    { pattern: /探测|探针|扫描/, tokens: ['probe', 'scan'] },
-    { pattern: /账号|账户|用户/, tokens: ['account', 'user'] },
-    { pattern: /注册|开户|报名/, tokens: ['register', 'signup'] },
-    { pattern: /验证|校验|激活/, tokens: ['verify', 'verification', 'activation'] },
-    { pattern: /验证码|图形验证码|人机验证/, tokens: ['captcha', 'verify', 'verification'] },
-    { pattern: /邮箱|邮件/, tokens: ['email', 'mail'] },
-    { pattern: /keygen|密钥|注册码|激活码/, tokens: ['keygen', 'key', 'activation'] },
-    { pattern: /轮询|监听/, tokens: ['poll', 'watch'] },
-    { pattern: /批量|并发/, tokens: ['batch', 'parallel'] },
-    { pattern: /令牌|凭证|鉴权|认证/, tokens: ['token', 'auth', 'credential'] },
-    { pattern: /提取|抽取|解析/, tokens: ['extract', 'parse'] },
-    { pattern: /多标签页|多标签|标签页/, tokens: ['tab', 'multi'] },
-    { pattern: /脚本库|脚本仓库/, tokens: ['script', 'library'] },
-    { pattern: /脚本/, tokens: ['script'] },
-    { pattern: /执行|运行/, tokens: ['run', 'execute'] },
-    { pattern: /导出/, tokens: ['export'] },
-    { pattern: /回放|重放/, tokens: ['replay'] },
-    { pattern: /请求/, tokens: ['request'] },
-];
 export class BM25ScorerImpl {
+    queryCategoryProfiles;
+    cjkQueryAliases;
+    constructor(searchConfig) {
+        this.queryCategoryProfiles =
+            searchConfig?.queryCategoryProfiles !== undefined
+                ? BM25ScorerImpl.compileQueryCategoryProfiles(searchConfig.queryCategoryProfiles)
+                : BM25ScorerImpl.compileQueryCategoryProfiles(DEFAULT_SEARCH_CONFIG.queryCategoryProfiles);
+        this.cjkQueryAliases =
+            searchConfig?.cjkQueryAliases !== undefined
+                ? BM25ScorerImpl.compileCjkQueryAliasRules(searchConfig.cjkQueryAliases)
+                : BM25ScorerImpl.compileCjkQueryAliasRules(DEFAULT_SEARCH_CONFIG.cjkQueryAliases);
+    }
+    static compileQueryCategoryProfiles(config) {
+        return config.flatMap((profile) => {
+            if (!profile || typeof profile.pattern !== 'string' || !Array.isArray(profile.domainBoosts)) {
+                return [];
+            }
+            let pattern;
+            try {
+                pattern = new RegExp(profile.pattern, profile.flags);
+            }
+            catch {
+                return [];
+            }
+            const domainBoosts = new Map(profile.domainBoosts.flatMap((boost) => {
+                if (!boost ||
+                    typeof boost.domain !== 'string' ||
+                    boost.domain.length === 0 ||
+                    typeof boost.weight !== 'number' ||
+                    !Number.isFinite(boost.weight)) {
+                    return [];
+                }
+                return [[boost.domain, boost.weight]];
+            }));
+            return [{ pattern, domainBoosts }];
+        });
+    }
+    static compileCjkQueryAliasRules(config) {
+        return config.flatMap((alias) => {
+            if (!alias || typeof alias.pattern !== 'string' || !Array.isArray(alias.tokens)) {
+                return [];
+            }
+            let pattern;
+            try {
+                pattern = new RegExp(alias.pattern, alias.flags);
+            }
+            catch {
+                return [];
+            }
+            const tokens = alias.tokens.filter((token) => typeof token === 'string' && token.length > 0);
+            return [{ pattern, tokens }];
+        });
+    }
     detectQueryCategoryBoosts(query) {
         const boosts = new Map();
-        for (const profile of QUERY_CATEGORY_PROFILES) {
+        for (const profile of this.queryCategoryProfiles) {
             if (!profile.pattern.test(query))
                 continue;
             for (const [domain, weight] of profile.domainBoosts) {
@@ -73,7 +70,7 @@ export class BM25ScorerImpl {
     expandCjkAliasTokens(text) {
         const lower = text.toLowerCase();
         const result = new Set();
-        for (const alias of CJK_QUERY_ALIASES) {
+        for (const alias of this.cjkQueryAliases) {
             if (alias.pattern.test(lower)) {
                 for (const token of alias.tokens) {
                     result.add(token);

package/dist/src/server/search/IntentBoost.d.ts

@@ -1,4 +1,4 @@
-import { type SearchIntentToolBoostRuleConfig } from '../../constants.js';
+import type { SearchIntentToolBoostRuleConfig } from '../../types/config.js';
 export type CompiledIntentToolBoostRule = {
     pattern: RegExp;
     boosts: ReadonlyArray<{
@@ -8,8 +8,8 @@ export type CompiledIntentToolBoostRule = {
 };
 export declare class IntentBoostImpl {
     private readonly compiledRules;
-    constructor();
-    static compileIntentToolBoostRules(config: SearchIntentToolBoostRuleConfig[] | null): ReadonlyArray<CompiledIntentToolBoostRule> | null;
+    constructor(intentToolBoostRules?: SearchIntentToolBoostRuleConfig[]);
+    static compileIntentToolBoostRules(config: SearchIntentToolBoostRuleConfig[]): ReadonlyArray<CompiledIntentToolBoostRule>;
     resolveIntentToolBonuses(query: string): Map<string, number>;
     getCompiledRules(): ReadonlyArray<CompiledIntentToolBoostRule>;
 }

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

@@ -1,63 +1,19 @@
-import { SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE, } from '../../constants.js';
-const DEFAULT_INTENT_TOOL_BOOST_RULES = [
-    {
-        pattern: /(?:端到端闭环|全链路闭环|一键闭环|api\s*capture\s*session|抓取接口|抓包流程)/i,
-        boosts: [
-            { tool: 'web_api_capture_session', bonus: 26 },
-            { tool: 'api_probe_batch', bonus: 18 },
-            { tool: 'network_extract_auth', bonus: 10 },
-            { tool: 'network_export_har', bonus: 8 },
-        ],
-    },
-    {
-        pattern: /(?:register|signup|sign\s*up|账号注册|账户注册|邮箱验证|验证账号|激活账号|注册验证|验证码|邮箱激活|激活链接|mail\s*verify|email\s*verify|account\s*pending|keygen)/i,
-        boosts: [
-            { tool: 'run_extension_workflow', bonus: 40 },
-            { tool: 'list_extension_workflows', bonus: 24 },
-            { tool: 'register_account_flow', bonus: 20 },
-            { tool: 'batch_register', bonus: 18 },
-            { tool: 'tab_workflow', bonus: 8 },
-        ],
-    },
-    {
-        pattern: /(?:script\s*library|script\s*preset|run\s*script|脚本库执行|脚本库|执行脚本)/i,
-        boosts: [
-            { tool: 'page_script_run', bonus: 22 },
-            { tool: 'page_script_register', bonus: 16 },
-            { tool: 'run_extension_workflow', bonus: 10 },
-        ],
-    },
-    {
-        pattern: /(?:bundle|webpack|js\s*bundle|脚本包|静态包|源码包)/i,
-        boosts: [
-            { tool: 'js_bundle_search', bonus: 20 },
-            { tool: 'source_map_extract', bonus: 10 },
-            { tool: 'webpack_enumerate', bonus: 8 },
-        ],
-    },
-    {
-        pattern: /(?:workflow|orchestration|工作流|流程编排|流程自动化)/i,
-        boosts: [
-            { tool: 'run_extension_workflow', bonus: 26 },
-            { tool: 'list_extension_workflows', bonus: 16 },
-            { tool: 'web_api_capture_session', bonus: 8 },
-        ],
-    },
-];
+import { DEFAULT_SEARCH_CONFIG } from '../../config/search-defaults.js';
 export class IntentBoostImpl {
     compiledRules;
-    constructor() {
+    constructor(intentToolBoostRules) {
         this.compiledRules =
-            IntentBoostImpl.compileIntentToolBoostRules(SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE) ??
-                DEFAULT_INTENT_TOOL_BOOST_RULES;
+            intentToolBoostRules !== undefined
+                ? IntentBoostImpl.compileIntentToolBoostRules(intentToolBoostRules)
+                : IntentBoostImpl.compileIntentToolBoostRules(DEFAULT_SEARCH_CONFIG.intentToolBoostRules);
     }
     static compileIntentToolBoostRules(config) {
-        if (!config || !Array.isArray(config)) {
-            return null;
-        }
         const compiled = [];
         for (const rule of config) {
-            if (!rule || typeof rule.pattern !== 'string' || !Array.isArray(rule.boosts) || rule.boosts.length === 0) {
+            if (!rule ||
+                typeof rule.pattern !== 'string' ||
+                !Array.isArray(rule.boosts) ||
+                rule.boosts.length === 0) {
                 continue;
             }
             let regex;
@@ -79,7 +35,7 @@ export class IntentBoostImpl {
             }
             compiled.push({ pattern: regex, boosts });
         }
-        return compiled.length > 0 ? compiled : null;
+        return compiled;
     }
     resolveIntentToolBonuses(query) {
         const lower = query.toLowerCase();

package/dist/src/server/search/ToolSearchEngineImpl.d.ts

@@ -1,4 +1,5 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { SearchConfig } from '../../types/config.js';
 export interface ToolSearchResult {
     name: string;
     domain: string | null;
@@ -21,7 +22,7 @@ export declare class ToolSearchEngine {
     private readonly queryCache;
     private readonly bm25Scorer;
     private readonly intentBoost;
-    constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>);
+    constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>, searchConfig?: SearchConfig);
     search(query: string, topK?: number, activeToolNames?: ReadonlySet<string>): ToolSearchResult[];
     getDomainSummary(): Array<{
         domain: string | null;