@jshookmcp/jshook 0.1.8 → 0.1.9

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

@@ -0,0 +1,202 @@
+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/src/modules/security/RedactionService.js

@@ -0,0 +1,101 @@
+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/src/server/MCPServer.boost.js

@@ -0,0 +1,334 @@
+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.registration.js

@@ -0,0 +1,29 @@
+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 === 'full' ||
+            explicitProfile === 'workflow' ||
+            explicitProfile === 'search'
+            ? explicitProfile
+            : 'search';
+        return { tools, profile };
+    }
+    let profile;
+    if (explicitProfile === 'full' ||
+        explicitProfile === 'workflow' ||
+        explicitProfile === 'search') {
+        profile = explicitProfile;
+    }
+    else {
+        profile = 'search';
+    }
+    const tools = getToolsForProfile(profile);
+    logger.info(`Tool registration mode=${profile}, transport=${transportMode}, count=${tools.length}`);
+    return { tools, profile };
+}

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

@@ -0,0 +1,4 @@
+import type { MCPServerContext } from './MCPServer.context.js';
+export { buildSearchSignature, getSearchEngine } from './MCPServer.search.helpers.js';
+export { buildDomainDescription } from './MCPServer.search.helpers.js';
+export declare function registerSearchMetaTools(ctx: MCPServerContext): void;