@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/utils/cache.additional.test.js

@@ -0,0 +1,141 @@
+import { promises as fs } from 'fs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+import { CacheManager } from '../../src/utils/cache.js';
+function createConfig(overrides) {
+    return {
+        enabled: true,
+        dir: '/tmp/jshookcp-cache-test',
+        ttl: 1,
+        ...overrides,
+    };
+}
+describe('CacheManager – additional coverage', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        loggerState.debug.mockReset();
+        loggerState.info.mockReset();
+        loggerState.warn.mockReset();
+        loggerState.error.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('init – disabled cache', () => {
+        it('skips directory creation when disabled', async () => {
+            const mkdirSpy = vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig({ enabled: false }));
+            await manager.init();
+            expect(mkdirSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('init – mkdir failure', () => {
+        it('logs error when mkdir fails', async () => {
+            vi.spyOn(fs, 'mkdir').mockRejectedValue(new Error('permission denied'));
+            const manager = new CacheManager(createConfig());
+            await manager.init();
+            expect(loggerState.error).toHaveBeenCalledWith('Failed to initialize cache directory', expect.any(Error));
+        });
+    });
+    describe('get – cache miss (lines 71-80)', () => {
+        it('returns null and logs cache miss on read error', async () => {
+            vi.spyOn(fs, 'readFile').mockRejectedValue(Object.assign(new Error('no such file'), { code: 'ENOENT' }));
+            const manager = new CacheManager(createConfig());
+            const result = await manager.get('missing-key');
+            expect(result).toBeNull();
+            expect(loggerState.debug).toHaveBeenCalledWith('Cache miss: missing-key');
+        });
+        it('returns null on JSON parse error', async () => {
+            vi.spyOn(fs, 'readFile').mockResolvedValue('not valid json{{{');
+            const manager = new CacheManager(createConfig());
+            const result = await manager.get('bad-json');
+            expect(result).toBeNull();
+            expect(loggerState.debug).toHaveBeenCalledWith('Cache miss: bad-json');
+        });
+    });
+    describe('set – disabled cache', () => {
+        it('skips write when disabled', async () => {
+            const writeSpy = vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig({ enabled: false }));
+            await manager.set('key', 'value');
+            expect(writeSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('set – write failure (lines 72-74)', () => {
+        it('logs error when write fails', async () => {
+            vi.spyOn(fs, 'writeFile').mockRejectedValue(new Error('disk full'));
+            const manager = new CacheManager(createConfig());
+            await manager.set('key', { data: 'value' });
+            expect(loggerState.error).toHaveBeenCalledWith('Failed to set cache', expect.any(Error));
+        });
+    });
+    describe('delete – disabled cache', () => {
+        it('skips delete when disabled', async () => {
+            const unlinkSpy = vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig({ enabled: false }));
+            await manager.delete('key');
+            expect(unlinkSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('clear – disabled cache', () => {
+        it('skips clear when disabled', async () => {
+            const readdirSpy = vi.spyOn(fs, 'readdir').mockResolvedValue([]);
+            const manager = new CacheManager(createConfig({ enabled: false }));
+            await manager.clear();
+            expect(readdirSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('clear – non-ENOENT error (lines 102-106)', () => {
+        it('logs error for non-ENOENT readdir failures', async () => {
+            vi.spyOn(fs, 'readdir').mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
+            const manager = new CacheManager(createConfig());
+            await manager.clear();
+            expect(loggerState.error).toHaveBeenCalledWith('Failed to clear cache', expect.any(Error));
+        });
+    });
+    describe('TTL expiry', () => {
+        it('returns cached value when within TTL', async () => {
+            const now = Date.now();
+            vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify({ timestamp: now - 500, value: { fresh: true } }));
+            const manager = new CacheManager(createConfig({ ttl: 10 }));
+            const result = await manager.get('within-ttl');
+            expect(result).toEqual({ fresh: true });
+        });
+        it('returns null and deletes when past TTL', async () => {
+            vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify({ timestamp: Date.now() - 60_000, value: { stale: true } }));
+            const unlinkSpy = vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig({ ttl: 5 }));
+            const result = await manager.get('past-ttl');
+            expect(result).toBeNull();
+            expect(unlinkSpy).toHaveBeenCalled();
+        });
+    });
+    describe('key hashing', () => {
+        it('uses consistent hashing for the same key', async () => {
+            const writeSpy = vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig());
+            await manager.set('test-key-123', 'value1');
+            await manager.set('test-key-123', 'value2');
+            const path1 = writeSpy.mock.calls[0]?.[0];
+            const path2 = writeSpy.mock.calls[1]?.[0];
+            expect(path1).toBe(path2);
+        });
+        it('uses different paths for different keys', async () => {
+            const writeSpy = vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+            const manager = new CacheManager(createConfig());
+            await manager.set('key-A', 'value1');
+            await manager.set('key-B', 'value2');
+            const path1 = writeSpy.mock.calls[0]?.[0];
+            const path2 = writeSpy.mock.calls[1]?.[0];
+            expect(path1).not.toBe(path2);
+        });
+    });
+});

package/dist/tests/utils/config.extended.test.js

@@ -9,6 +9,9 @@ describe('config validation – extended checks', () => {
         delete process.env.CACHE_TTL;
         delete process.env.MAX_CONCURRENT_ANALYSIS;
         delete process.env.MAX_CODE_SIZE_MB;
+        delete process.env.SEARCH_QUERY_CATEGORY_PROFILES_JSON;
+        delete process.env.SEARCH_CJK_QUERY_ALIASES_JSON;
+        delete process.env.SEARCH_INTENT_TOOL_BOOST_RULES_JSON;
     });
     afterEach(() => {
         process.env = { ...originalEnv };
@@ -43,4 +46,24 @@ describe('config validation – extended checks', () => {
         const config = getConfig();
         expect(config.performance.maxConcurrentAnalysis).toBe(8);
     });
+    it('falls back to default search config when search json is invalid', () => {
+        process.env.SEARCH_QUERY_CATEGORY_PROFILES_JSON = '{bad-json';
+        process.env.SEARCH_CJK_QUERY_ALIASES_JSON = '{"bad":"json"}';
+        process.env.SEARCH_INTENT_TOOL_BOOST_RULES_JSON = '{still-bad-json';
+        const config = getConfig();
+        expect(config.search.queryCategoryProfiles.length).toBeGreaterThan(0);
+        expect(config.search.cjkQueryAliases.length).toBeGreaterThan(0);
+        expect(config.search.intentToolBoostRules.length).toBeGreaterThan(0);
+    });
+    it('validateConfig reports invalid search regex patterns', () => {
+        const config = getConfig();
+        config.search.queryCategoryProfiles[0].pattern = '[invalid';
+        config.search.cjkQueryAliases[0].pattern = '[invalid';
+        config.search.intentToolBoostRules[0].pattern = '[invalid';
+        const result = validateConfig(config);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain('search.queryCategoryProfiles contains invalid regex: [invalid');
+        expect(result.errors).toContain('search.cjkQueryAliases contains invalid regex: [invalid');
+        expect(result.errors).toContain('search.intentToolBoostRules contains invalid regex: [invalid');
+    });
 });

package/dist/tests/utils/config.test.js

@@ -16,6 +16,9 @@ describe('config utilities', () => {
         delete process.env.CACHE_DIR;
         delete process.env.MAX_CONCURRENT_ANALYSIS;
         delete process.env.MAX_CODE_SIZE_MB;
+        delete process.env.SEARCH_QUERY_CATEGORY_PROFILES_JSON;
+        delete process.env.SEARCH_CJK_QUERY_ALIASES_JSON;
+        delete process.env.SEARCH_INTENT_TOOL_BOOST_RULES_JSON;
         for (const provider of getSupportedProviders()) {
             delete process.env[`${provider.toUpperCase()}_API_KEY`];
             delete process.env[`${provider.toUpperCase()}_MODEL`];
@@ -32,6 +35,9 @@ describe('config utilities', () => {
         expect(config.puppeteer.timeout).toBe(30000);
         expect(config.cache.ttl).toBe(3600);
         expect(config.performance.maxConcurrentAnalysis).toBe(3);
+        expect(config.search.queryCategoryProfiles.length).toBeGreaterThan(0);
+        expect(config.search.cjkQueryAliases.length).toBeGreaterThan(0);
+        expect(config.search.intentToolBoostRules.length).toBeGreaterThan(0);
     });
     it('reads provider and credentials from environment', () => {
         const defaultProvider = getConfig().llm.provider;
@@ -68,4 +74,48 @@ describe('config utilities', () => {
         expect(result.errors).toContain('maxConcurrentAnalysis must be at least 1');
         expect(result.errors).toContain('maxCodeSizeMB must be at least 1');
     });
+    it('reads search rule overrides from environment json', () => {
+        process.env.SEARCH_QUERY_CATEGORY_PROFILES_JSON = JSON.stringify([
+            {
+                pattern: 'custom-query',
+                flags: 'i',
+                domainBoosts: [{ domain: 'browser', weight: 2 }],
+            },
+        ]);
+        process.env.SEARCH_CJK_QUERY_ALIASES_JSON = JSON.stringify([
+            {
+                pattern: '自定义',
+                tokens: ['custom-token'],
+            },
+        ]);
+        process.env.SEARCH_INTENT_TOOL_BOOST_RULES_JSON = JSON.stringify([
+            {
+                pattern: '自定义流程',
+                flags: 'i',
+                boosts: [{ tool: 'run_extension_workflow', bonus: 99 }],
+            },
+        ]);
+        const config = getConfig();
+        expect(config.search.queryCategoryProfiles).toEqual([
+            {
+                pattern: 'custom-query',
+                flags: 'i',
+                domainBoosts: [{ domain: 'browser', weight: 2 }],
+            },
+        ]);
+        expect(config.search.cjkQueryAliases).toEqual([
+            {
+                pattern: '自定义',
+                flags: undefined,
+                tokens: ['custom-token'],
+            },
+        ]);
+        expect(config.search.intentToolBoostRules).toEqual([
+            {
+                pattern: '自定义流程',
+                flags: 'i',
+                boosts: [{ tool: 'run_extension_workflow', bonus: 99 }],
+            },
+        ]);
+    });
 });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@jshookmcp/jshook",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "packageManager": "pnpm@10.28.2",
-  "description": "MCP server with 244 built-in tools (236 domain tools across 16 domains) for AI-assisted JavaScript analysis and security analysis — browser automation, CDP debugging, network monitoring, JS hooks, code analysis, and workflow orchestration",
+  "description": "MCP server with 238 built-in tools (224 domain tools across 16 domains) for AI-assisted JavaScript analysis and security analysis — browser automation, CDP debugging, network monitoring, JS hooks, code analysis, and workflow orchestration",
   "mcpName": "io.github.vmoranv/jshookmcp",
   "main": "dist/src/index.js",
   "type": "module",
@@ -111,6 +111,7 @@
     "@types/node": "^25.3.0",
     "@typescript-eslint/eslint-plugin": "^8.56.1",
     "@typescript-eslint/parser": "^8.56.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "cross-env": "^10.1.0",
     "eslint": "^10.0.2",
     "estree-walker": "^2.0.2",
@@ -120,7 +121,6 @@
     "tsc-alias": "^1.8.16",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "@vitest/coverage-v8": "^4.0.18",
     "vite": "^6.0.0",
     "vitepress": "1.6.4",
     "vitest": "^4.0.18"

package/dist/src/server/MCPServer.boost.d.ts

@@ -1,8 +0,0 @@
-import { type ToolProfile } from './ToolCatalog.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-export declare function boostProfile(ctx: MCPServerContext, target?: string, ttlMinutes?: number): Promise<Record<string, unknown>>;
-export declare function boostProfileInner(ctx: MCPServerContext, target?: string, ttlMinutesOverride?: number): Promise<Record<string, unknown>>;
-export declare function unboostProfile(ctx: MCPServerContext, target?: string): Promise<Record<string, unknown>>;
-export declare function unboostProfileInner(ctx: MCPServerContext, target?: string): Promise<Record<string, unknown>>;
-export declare function switchToTier(ctx: MCPServerContext, targetTier: ToolProfile): Promise<void>;
-export declare function refreshBoostTtl(ctx: MCPServerContext): void;

package/dist/src/server/MCPServer.boost.js

@@ -1,334 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { TIER_DEFAULT_TTL, TIER_ORDER, getProfileDomains, getTierIndex, getToolDomain, getToolsForProfile, } from './ToolCatalog.js';
-import { createToolHandlerMap } from './ToolHandlerMap.js';
-export async function boostProfile(ctx, target, ttlMinutes) {
-    const prev = ctx.boostLock;
-    let resolve;
-    ctx.boostLock = new Promise((r) => {
-        resolve = r;
-    });
-    await prev;
-    try {
-        return await boostProfileInner(ctx, target, ttlMinutes);
-    }
-    finally {
-        resolve();
-    }
-}
-export async function boostProfileInner(ctx, target, ttlMinutesOverride) {
-    const currentIdx = getTierIndex(ctx.currentTier);
-    let resolvedTarget;
-    if (target) {
-        resolvedTarget = target;
-        const targetIdx = getTierIndex(resolvedTarget);
-        if (targetIdx < 0) {
-            return {
-                success: false,
-                error: `Unknown tier "${target}". Available tiers: ${TIER_ORDER.join(', ')}.`,
-                currentTier: ctx.currentTier,
-                availableTiers: [...TIER_ORDER],
-            };
-        }
-        else if (targetIdx <= currentIdx) {
-            return {
-                success: false,
-                error: `Already at tier "${ctx.currentTier}" (index ${currentIdx}). Target "${resolvedTarget}" is not higher. Use unboost_profile to downgrade.`,
-                currentTier: ctx.currentTier,
-                availableTiers: [...TIER_ORDER],
-            };
-        }
-    }
-    else {
-        if (currentIdx < 0 || currentIdx >= TIER_ORDER.length - 1) {
-            return {
-                success: false,
-                error: `Already at highest tier "${ctx.currentTier}". Nothing to boost to.`,
-                currentTier: ctx.currentTier,
-                availableTiers: [...TIER_ORDER],
-            };
-        }
-        resolvedTarget = TIER_ORDER[currentIdx + 1];
-    }
-    if (ctx.boostTtlTimer) {
-        clearTimeout(ctx.boostTtlTimer);
-        ctx.boostTtlTimer = null;
-    }
-    await switchToTier(ctx, resolvedTarget);
-    ctx.boostHistory.push(ctx.currentTier);
-    ctx.currentTier = resolvedTarget;
-    const ttlMinutes = ttlMinutesOverride ?? TIER_DEFAULT_TTL[resolvedTarget] ?? 30;
-    ctx.boostTtlMinutes = ttlMinutes;
-    if (ttlMinutes > 0) {
-        ctx.boostTtlTimer = setTimeout(() => {
-            logger.info(`boost_profile TTL expired (${ttlMinutes}min) — auto-downgrading from "${ctx.currentTier}"`);
-            void unboostProfile(ctx).catch((err) => {
-                logger.error('Auto-unboost after TTL expiry failed:', err);
-            });
-        }, ttlMinutes * 60 * 1000);
-    }
-    try {
-        await ctx.server.sendToolListChanged();
-    }
-    catch (e) {
-        logger.warn('sendToolListChanged failed:', e);
-    }
-    const addedNames = [...ctx.boostedToolNames];
-    logger.info(`Boosted to "${resolvedTarget}": added ${addedNames.length} tools`);
-    return {
-        success: true,
-        previousTier: ctx.boostHistory[ctx.boostHistory.length - 1],
-        currentTier: resolvedTarget,
-        addedTools: addedNames.length,
-        ttlMinutes: ttlMinutes > 0 ? ttlMinutes : 'disabled',
-        addedToolNames: addedNames,
-        availableTiers: [...TIER_ORDER],
-        hint: 'Call unboost_profile to downgrade, or tools auto-expire after TTL.',
-    };
-}
-export async function unboostProfile(ctx, target) {
-    const prev = ctx.boostLock;
-    let resolve;
-    ctx.boostLock = new Promise((r) => {
-        resolve = r;
-    });
-    await prev;
-    try {
-        return await unboostProfileInner(ctx, target);
-    }
-    finally {
-        resolve();
-    }
-}
-export async function unboostProfileInner(ctx, target) {
-    if (ctx.currentTier === ctx.baseTier && ctx.boostHistory.length === 0) {
-        return {
-            success: true,
-            currentTier: ctx.currentTier,
-            removedTools: 0,
-            message: 'Already at base tier; nothing to downgrade.',
-        };
-    }
-    if (ctx.boostTtlTimer) {
-        clearTimeout(ctx.boostTtlTimer);
-        ctx.boostTtlTimer = null;
-    }
-    const previousTier = ctx.currentTier;
-    let resolvedTarget;
-    if (target) {
-        resolvedTarget = target;
-        if (getTierIndex(resolvedTarget) < 0) {
-            return {
-                success: false,
-                error: `Unknown tier "${target}". Available tiers: ${TIER_ORDER.join(', ')}.`,
-                currentTier: ctx.currentTier,
-                availableTiers: [...TIER_ORDER],
-            };
-        }
-    }
-    else {
-        resolvedTarget = ctx.boostHistory.length > 0 ? ctx.boostHistory.pop() : ctx.baseTier;
-    }
-    if (target) {
-        while (ctx.boostHistory.length > 0 &&
-            ctx.boostHistory[ctx.boostHistory.length - 1] !== resolvedTarget) {
-            ctx.boostHistory.pop();
-        }
-        if (ctx.boostHistory.length > 0 &&
-            ctx.boostHistory[ctx.boostHistory.length - 1] === resolvedTarget) {
-            ctx.boostHistory.pop();
-        }
-    }
-    const removedCount = ctx.boostedToolNames.size;
-    await switchToTier(ctx, resolvedTarget);
-    ctx.currentTier = resolvedTarget;
-    try {
-        await ctx.server.sendToolListChanged();
-    }
-    catch (e) {
-        logger.warn('sendToolListChanged failed:', e);
-    }
-    logger.info(`Downgraded from "${previousTier}" to "${resolvedTarget}": removed ${removedCount} tools`);
-    return {
-        success: true,
-        previousTier,
-        currentTier: resolvedTarget,
-        removedTools: removedCount,
-        message: `Downgraded from "${previousTier}" to "${resolvedTarget}".`,
-        availableTiers: [...TIER_ORDER],
-    };
-}
-export async function switchToTier(ctx, targetTier) {
-    const removeFailures = [];
-    for (const name of ctx.boostedToolNames) {
-        if (ctx.absorbedFromActivated.has(name)) {
-            const registeredTool = ctx.boostedRegisteredTools.get(name);
-            if (registeredTool) {
-                ctx.activatedToolNames.add(name);
-                ctx.activatedRegisteredTools.set(name, registeredTool);
-            }
-        }
-        else {
-            const registeredTool = ctx.boostedRegisteredTools.get(name);
-            if (registeredTool) {
-                try {
-                    registeredTool.remove();
-                }
-                catch (e) {
-                    removeFailures.push(name);
-                    logger.warn(`Failed to remove boosted tool "${name}" from SDK:`, e);
-                }
-            }
-            ctx.router.removeHandler(name);
-        }
-    }
-    if (removeFailures.length > 0) {
-        logger.warn(`switchToTier: ${removeFailures.length} tool(s) failed SDK removal — ` +
-            `SDK state may be inconsistent: [${removeFailures.join(', ')}]`);
-    }
-    ctx.boostedRegisteredTools.clear();
-    ctx.boostedToolNames.clear();
-    ctx.absorbedFromActivated.clear();
-    if (targetTier === ctx.baseTier) {
-        ctx.enabledDomains = ctx.resolveEnabledDomains(ctx.selectedTools);
-        for (const name of ctx.activatedToolNames) {
-            const domain = getToolDomain(name);
-            if (domain)
-                ctx.enabledDomains.add(domain);
-        }
-        manageExtensionToolsForTier(ctx, targetTier);
-        return;
-    }
-    const targetTools = getToolsForProfile(targetTier);
-    const excludeNames = new Set(ctx.selectedTools.map((t) => t.name));
-    for (const name of ctx.activatedToolNames) {
-        excludeNames.add(name);
-    }
-    const newTools = targetTools.filter((t) => !excludeNames.has(t.name));
-    const absorbedFromActivated = [];
-    const targetNameSet = new Set(targetTools.map((t) => t.name));
-    for (const name of ctx.activatedToolNames) {
-        if (targetNameSet.has(name)) {
-            const registeredTool = ctx.activatedRegisteredTools.get(name);
-            if (registeredTool) {
-                ctx.boostedToolNames.add(name);
-                ctx.boostedRegisteredTools.set(name, registeredTool);
-                ctx.absorbedFromActivated.add(name);
-            }
-            ctx.activatedToolNames.delete(name);
-            ctx.activatedRegisteredTools.delete(name);
-            absorbedFromActivated.push(name);
-        }
-    }
-    if (absorbedFromActivated.length > 0) {
-        logger.info(`switchToTier: absorbed ${absorbedFromActivated.length} activated tools into boost set`);
-    }
-    ctx.enabledDomains = ctx.resolveEnabledDomains(ctx.selectedTools);
-    for (const domain of getProfileDomains(targetTier)) {
-        ctx.enabledDomains.add(domain);
-    }
-    const registered = [];
-    try {
-        for (const toolDef of newTools) {
-            const registeredTool = ctx.registerSingleTool(toolDef);
-            ctx.boostedToolNames.add(toolDef.name);
-            ctx.boostedRegisteredTools.set(toolDef.name, registeredTool);
-            registered.push({ name: toolDef.name, registeredTool });
-        }
-    }
-    catch (error) {
-        for (const { name, registeredTool } of registered) {
-            try {
-                registeredTool.remove();
-            }
-            catch (e) {
-                logger.warn(`Rollback: failed to remove tool "${name}":`, e);
-            }
-            ctx.boostedToolNames.delete(name);
-            ctx.boostedRegisteredTools.delete(name);
-        }
-        for (const name of absorbedFromActivated) {
-            const rt = ctx.boostedRegisteredTools.get(name);
-            if (rt) {
-                ctx.activatedToolNames.add(name);
-                ctx.activatedRegisteredTools.set(name, rt);
-                ctx.boostedToolNames.delete(name);
-                ctx.boostedRegisteredTools.delete(name);
-            }
-        }
-        throw error;
-    }
-    const newToolNames = new Set(newTools.map((t) => t.name));
-    const newHandlers = createToolHandlerMap(ctx.handlerDeps, newToolNames);
-    ctx.router.addHandlers(newHandlers);
-    manageExtensionToolsForTier(ctx, targetTier);
-}
-export function refreshBoostTtl(ctx) {
-    if (ctx.boostTtlMinutes <= 0)
-        return;
-    if (ctx.currentTier === ctx.baseTier)
-        return;
-    if (ctx.boostTtlTimer) {
-        clearTimeout(ctx.boostTtlTimer);
-    }
-    ctx.boostTtlTimer = setTimeout(() => {
-        logger.info(`boost_profile TTL expired (${ctx.boostTtlMinutes}min) — auto-downgrading from "${ctx.currentTier}"`);
-        void unboostProfile(ctx).catch((err) => {
-            logger.error('Auto-unboost after TTL refresh expiry failed:', err);
-        });
-    }, ctx.boostTtlMinutes * 60 * 1000);
-}
-function manageExtensionToolsForTier(ctx, targetTier) {
-    const targetIdx = getTierIndex(targetTier);
-    if (targetIdx < 0)
-        return;
-    for (const [name, record] of ctx.extensionToolsByName) {
-        if (!record.boostTier)
-            continue;
-        const boostIdx = getTierIndex(record.boostTier);
-        if (boostIdx < 0)
-            continue;
-        const shouldBeActive = targetIdx >= boostIdx;
-        const isBoostRegistered = ctx.boostedExtensionToolNames.has(name);
-        const isManuallyActivated = ctx.activatedToolNames.has(name);
-        if (shouldBeActive && !isBoostRegistered && !isManuallyActivated && !record.registeredTool) {
-            try {
-                const registeredTool = ctx.registerSingleTool(record.tool);
-                if (record.handler) {
-                    try {
-                        ctx.router.addHandlers({ [name]: record.handler });
-                    }
-                    catch (routerError) {
-                        try {
-                            registeredTool.remove();
-                        }
-                        catch { }
-                        logger.warn(`Failed to add router handler for extension tool "${name}":`, routerError);
-                        continue;
-                    }
-                }
-                record.registeredTool = registeredTool;
-                ctx.boostedExtensionToolNames.add(name);
-                if (record.domain)
-                    ctx.enabledDomains.add(record.domain);
-                logger.info(`Auto-registered extension tool "${name}" (boostTier=${record.boostTier})`);
-            }
-            catch (error) {
-                logger.warn(`Failed to auto-register extension tool "${name}":`, error);
-            }
-        }
-        else if (!shouldBeActive && isBoostRegistered) {
-            try {
-                if (record.registeredTool) {
-                    record.registeredTool.remove();
-                    record.registeredTool = undefined;
-                }
-                ctx.router.removeHandler(name);
-                ctx.boostedExtensionToolNames.delete(name);
-                logger.info(`Auto-deregistered extension tool "${name}" (boostTier=${record.boostTier})`);
-            }
-            catch (error) {
-                logger.warn(`Failed to deregister extension tool "${name}":`, error);
-            }
-        }
-    }
-}

package/dist/src/server/MCPServer.search.dynamicBoost.d.ts

@@ -1,36 +0,0 @@
-import { type ToolProfile } from './ToolCatalog.js';
-import type { MCPServerContext } from './MCPServer.context.js';
-import { type DynamicBoostStrategy } from '../constants.js';
-export interface SearchResult {
-    name: string;
-    domain: string | null;
-    score: number;
-    isActive: boolean;
-}
-export interface AnalyzeOptions {
-    scoreThreshold?: number;
-    minCandidates?: number;
-    strategy?: DynamicBoostStrategy;
-}
-export interface RetryOptions {
-    maxAttempts?: number;
-    initialDelay?: number;
-    exponentialBackoff?: boolean;
-}
-export interface TierAnalysis {
-    targetTier: ToolProfile | null;
-    tierCounts: Record<ToolProfile, number>;
-    considered: string[];
-}
-export declare function analyzeSearchResultTiers(ctx: MCPServerContext, results: SearchResult[], activeNames: Set<string>, opts?: AnalyzeOptions): TierAnalysis;
-export interface GuardrailResult {
-    allowed: boolean;
-    reason?: string;
-    adjustedTier?: ToolProfile;
-}
-export declare function validateBoostGuardrails(currentTier: ToolProfile, targetTier: ToolProfile): GuardrailResult;
-export declare function silentBoostToTierWithRetry(ctx: MCPServerContext, targetTier: ToolProfile, opts?: RetryOptions): Promise<{
-    success: boolean;
-    attempts: number;
-}>;
-export declare function backfillIsActive(results: SearchResult[], activeNames: Set<string>): SearchResult[];