@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/modules/process/memory/writer.js

@@ -1,202 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
-import { isKoffiAvailable } from '../../../native/Win32API.js';
-import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
-async function writeMemoryWindows(pid, address, data) {
-    try {
-        const hexData = data.toString('hex').toUpperCase();
-        const psScript = `
-        Add-Type @"
-          using System;
-          using System.Runtime.InteropServices;
-          using System.ComponentModel;
-
-          public class MemoryWriter {
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool CloseHandle(IntPtr handle);
-
-            const int PROCESS_VM_WRITE = 0x0020;
-            const int PROCESS_VM_OPERATION = 0x0008;
-
-            public static int WriteMemory(int pid, long address, string hexData) {
-              IntPtr hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pid);
-              if (hProcess == IntPtr.Zero) {
-                int error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-              }
-
-              try {
-                byte[] buffer = new byte[hexData.Length / 2];
-                for (int i = 0; i < hexData.Length; i += 2) {
-                  buffer[i / 2] = Convert.ToByte(hexData.Substring(i, 2), 16);
-                }
-
-                int bytesWritten;
-                bool success = WriteProcessMemory(hProcess, (IntPtr)address, buffer, buffer.Length, out bytesWritten);
-
-                if (!success) {
-                  int error = Marshal.GetLastWin32Error();
-                  throw new Win32Exception(error, "Failed to write memory");
-                }
-
-                return bytesWritten;
-              } finally {
-                CloseHandle(hProcess);
-              }
-            }
-          }
-"@
-
-        try {
-          $bytesWritten = [MemoryWriter]::WriteMemory(${pid}, ${address}, "${hexData}")
-          @{ success = $true; bytesWritten = $bytesWritten } | ConvertTo-Json -Compress
-        } catch {
-          @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-        }
-      `;
-        const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024 });
-        const _trimmed = stdout.trim();
-        if (!_trimmed)
-            throw new Error('PowerShell returned empty output');
-        const result = JSON.parse(_trimmed);
-        return {
-            success: result.success,
-            bytesWritten: result.bytesWritten,
-            error: result.error,
-        };
-    }
-    catch (error) {
-        logger.error('Windows memory write failed:', error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed. Run as Administrator.',
-        };
-    }
-}
-async function writeMemoryLinux(pid, address, data) {
-    try {
-        const hexData = data.toString('hex');
-        const { stderr } = await execAsync(`sudo sh -c 'printf "${hexData}" | xxd -r -p | dd of=/proc/${pid}/mem bs=1 seek=${address} conv=notrunc 2>&1' || echo ""`, { maxBuffer: 1024 * 1024, timeout: 10000 });
-        if (stderr && stderr.includes('error')) {
-            return {
-                success: false,
-                error: 'Memory write failed. Requires root privileges.',
-            };
-        }
-        return {
-            success: true,
-            bytesWritten: data.length,
-        };
-    }
-    catch (error) {
-        logger.error('Linux memory write failed:', error);
-        return {
-            success: false,
-            error: 'Memory write failed. Run as root.',
-        };
-    }
-}
-async function writeMemoryMac(pid, address, data, checkProtectionFn) {
-    if (address === 0) {
-        return { success: false, error: 'Invalid address: null pointer (0x0)' };
-    }
-    const MAX_WRITE_SIZE = 16 * 1024;
-    if (data.length === 0 || data.length > MAX_WRITE_SIZE) {
-        return { success: false, error: `Invalid write size: must be 1–${MAX_WRITE_SIZE} bytes` };
-    }
-    const addrHex = `0x${address.toString(16)}`;
-    const prot = await checkProtectionFn(pid, addrHex);
-    if (!prot.success) {
-        return { success: false, error: `Cannot verify memory region: ${prot.error}` };
-    }
-    if (!prot.isWritable) {
-        return { success: false, error: `Address ${addrHex} is not writable (protection: ${prot.protection ?? 'unknown'})` };
-    }
-    try {
-        const hexBytes = Array.from(data)
-            .map(b => `0x${b.toString(16).padStart(2, '0')}`)
-            .join(' ');
-        const { stdout } = await execAsync(`lldb --batch -p ${pid} -o "memory write ${addrHex} ${hexBytes}" -o "process detach"`, { timeout: 10000, maxBuffer: 1024 * 1024 });
-        if (stdout.includes('error:')) {
-            const errLine = stdout.split('\n').find(l => l.includes('error:')) ?? stdout;
-            return { success: false, error: `lldb memory write failed: ${errLine.trim()}` };
-        }
-        return { success: true, bytesWritten: data.length };
-    }
-    catch (error) {
-        return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-}
-export async function writeMemory(platform, pid, address, data, encoding = 'hex', checkProtectionFn) {
-    try {
-        const addrNum = parseInt(address, 16);
-        if (isNaN(addrNum)) {
-            return { success: false, error: 'Invalid address format' };
-        }
-        let buffer;
-        try {
-            if (encoding === 'base64') {
-                buffer = Buffer.from(data, 'base64');
-            }
-            else {
-                const cleanHex = data.replace(/\s/g, '');
-                buffer = Buffer.from(cleanHex, 'hex');
-            }
-        }
-        catch (_e) {
-            return { success: false, error: `Invalid ${encoding} data` };
-        }
-        if (platform === 'win32' && isKoffiAvailable()) {
-            try {
-                const result = await nativeMemoryManager.writeMemory(pid, address, data, encoding);
-                if (result.success) {
-                    logger.debug('Native memory write succeeded');
-                    return result;
-                }
-                logger.warn('Native memory write failed, falling back to PowerShell:', result.error);
-            }
-            catch (nativeError) {
-                logger.warn('Native memory write error, falling back to PowerShell:', nativeError);
-            }
-        }
-        switch (platform) {
-            case 'win32':
-                return writeMemoryWindows(pid, addrNum, buffer);
-            case 'linux':
-                return writeMemoryLinux(pid, addrNum, buffer);
-            case 'darwin':
-                return writeMemoryMac(pid, addrNum, buffer, checkProtectionFn);
-            default:
-                return { success: false, error: `Memory operations not supported on platform: ${platform}` };
-        }
-    }
-    catch (error) {
-        logger.error('Memory write failed:', error);
-        return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-}
-export async function batchMemoryWrite(pid, patches, writeFn) {
-    const results = [];
-    for (const patch of patches) {
-        const result = await writeFn(pid, patch.address, patch.data, patch.encoding || 'hex');
-        results.push({
-            address: patch.address,
-            success: result.success,
-            error: result.error,
-        });
-    }
-    const allSuccess = results.every(r => r.success);
-    return {
-        success: allSuccess,
-        results,
-        error: allSuccess
-            ? undefined
-            : `Failed to write ${results.filter(r => !r.success).length} of ${results.length} patches`,
-    };
-}

package/dist/modules/security/RedactionService.js

@@ -1,101 +0,0 @@
-import { logger } from '../../utils/logger.js';
-const PATTERNS = [
-    {
-        name: 'bearer_token',
-        pattern: /Bearer\s+[A-Za-z0-9_\-.~+/]+=*/g,
-        replacement: 'Bearer [REDACTED]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'jwt',
-        pattern: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
-        replacement: '[REDACTED_JWT]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'api_key_sk',
-        pattern: /sk[_-][A-Za-z0-9]{20,}/g,
-        replacement: '[REDACTED_API_KEY]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'api_key_generic',
-        pattern: /(?:api[_-]?key|apikey|access[_-]?key)\s*[:=]\s*["']?[A-Za-z0-9_\-]{16,}["']?/gi,
-        replacement: '[REDACTED_API_KEY]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'long_hex_secret',
-        pattern: /(?:secret|token|password|passwd|credential)\s*[:=]\s*["']?[A-Fa-f0-9]{32,}["']?/gi,
-        replacement: '[REDACTED_SECRET]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'cookie_header',
-        pattern: /(?:Cookie|Set-Cookie)\s*:\s*[^\r\n]{10,}/gi,
-        replacement: '[REDACTED_COOKIE]',
-        levels: ['standard', 'strict'],
-    },
-    {
-        name: 'email',
-        pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
-        replacement: '[REDACTED_EMAIL]',
-        levels: ['strict'],
-    },
-    {
-        name: 'windows_absolute_path',
-        pattern: /[A-Z]:\\(?:Users|Documents and Settings)\\[^\s"'<>|]{3,}/gi,
-        replacement: '[REDACTED_PATH]',
-        levels: ['strict'],
-    },
-    {
-        name: 'unix_home_path',
-        pattern: /\/(?:home|Users)\/[a-zA-Z0-9._-]+(?:\/[^\s"'<>|]+)*/g,
-        replacement: '[REDACTED_PATH]',
-        levels: ['strict'],
-    },
-];
-export class RedactionService {
-    level;
-    activePatterns;
-    constructor(level) {
-        this.level = level ?? process.env.jshook_REDACTION_LEVEL ?? 'standard';
-        this.activePatterns = PATTERNS.filter((p) => p.levels.includes(this.level));
-    }
-    redactString(input) {
-        if (this.level === 'none')
-            return input;
-        let result = input;
-        for (const pattern of this.activePatterns) {
-            result = result.replace(pattern.pattern, pattern.replacement);
-        }
-        return result;
-    }
-    redactObject(obj) {
-        if (this.level === 'none')
-            return obj;
-        try {
-            const json = JSON.stringify(obj);
-            const redacted = this.redactString(json);
-            return JSON.parse(redacted);
-        }
-        catch {
-            return obj;
-        }
-    }
-    setLevel(level) {
-        this.level = level;
-        this.activePatterns = PATTERNS.filter((p) => p.levels.includes(level));
-        logger.info(`[RedactionService] Level set to: ${level} (${this.activePatterns.length} patterns active)`);
-    }
-    getLevel() {
-        return this.level;
-    }
-    getStats() {
-        return {
-            level: this.level,
-            activePatterns: this.activePatterns.length,
-            patternNames: this.activePatterns.map((p) => p.name),
-        };
-    }
-}

package/dist/server/MCPServer.boost.js

@@ -1,336 +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) {
-        const normalized = target === 'min' ? 'minimal' : target;
-        resolvedTarget = normalized;
-        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) {
-        const normalized = target === 'min' ? 'minimal' : target;
-        resolvedTarget = normalized;
-        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/server/MCPServer.registration.js

@@ -1,31 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { getToolsByDomains, getToolsForProfile, parseToolDomains, } from './ToolCatalog.js';
-export function resolveToolsForRegistration() {
-    const transportMode = (process.env.MCP_TRANSPORT ?? 'stdio').toLowerCase();
-    const explicitProfile = (process.env.MCP_TOOL_PROFILE ?? '').trim().toLowerCase();
-    const explicitDomains = parseToolDomains(process.env.MCP_TOOL_DOMAINS);
-    if (explicitDomains && explicitDomains.length > 0) {
-        const tools = getToolsByDomains(explicitDomains);
-        logger.info(`Tool registration mode=domains [${explicitDomains.join(',')}], count=${tools.length}`);
-        const profile = explicitProfile === 'minimal' ||
-            explicitProfile === 'full' ||
-            explicitProfile === 'workflow' ||
-            explicitProfile === 'search'
-            ? explicitProfile
-            : 'minimal';
-        return { tools, profile };
-    }
-    let profile;
-    if (explicitProfile === 'minimal' ||
-        explicitProfile === 'full' ||
-        explicitProfile === 'workflow' ||
-        explicitProfile === 'search') {
-        profile = explicitProfile;
-    }
-    else {
-        profile = 'minimal';
-    }
-    const tools = getToolsForProfile(profile);
-    logger.info(`Tool registration mode=${profile}, transport=${transportMode}, count=${tools.length}`);
-    return { tools, profile };
-}

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

@@ -1,5 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import { ToolSearchEngine } from './ToolSearch.js';
-export declare function buildSearchSignature(ctx: MCPServerContext): string;
-export declare function getSearchEngine(ctx: MCPServerContext): ToolSearchEngine;
-export declare function registerSearchMetaTools(ctx: MCPServerContext): void;