@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,91 +0,0 @@
-import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-function asJsonResource(uri, payload) {
-    return {
-        contents: [
-            {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify(payload, null, 2),
-            },
-        ],
-    };
-}
-function asTextResource(uri, text, mimeType) {
-    return {
-        contents: [
-            {
-                uri,
-                mimeType,
-                text,
-            },
-        ],
-    };
-}
-function getEvidenceGraph(ctx) {
-    return ctx.getDomainInstance('evidenceGraph');
-}
-function getSessionManager(ctx) {
-    return ctx.getDomainInstance('instrumentationSessionManager');
-}
-export function registerServerResources(ctx) {
-    ctx.server.registerResource('evidence_graph_json', 'jshook://evidence/graph', {
-        title: 'Evidence Graph JSON',
-        description: 'Serializable snapshot of the current reverse evidence graph.',
-        mimeType: 'application/json',
-    }, async (uri) => {
-        const graph = getEvidenceGraph(ctx);
-        return asJsonResource(uri.toString(), graph
-            ? graph.exportJson()
-            : { version: 1, nodes: [], edges: [], exportedAt: new Date().toISOString() });
-    });
-    ctx.server.registerResource('evidence_graph_markdown', 'jshook://evidence/graph.md', {
-        title: 'Evidence Graph Markdown',
-        description: 'Markdown report for the current reverse evidence graph.',
-        mimeType: 'text/markdown',
-    }, async (uri) => {
-        const graph = getEvidenceGraph(ctx);
-        return asTextResource(uri.toString(), graph
-            ? graph.exportMarkdown()
-            : '# Reverse Evidence Graph Report\n\nNo evidence graph is available.\n', 'text/markdown');
-    });
-    ctx.server.registerResource('instrumentation_sessions', 'jshook://instrumentation/sessions', {
-        title: 'Instrumentation Sessions',
-        description: 'Expanded snapshots for all active instrumentation sessions.',
-        mimeType: 'application/json',
-    }, async (uri) => {
-        const manager = getSessionManager(ctx);
-        return asJsonResource(uri.toString(), manager ? manager.listSessionSnapshots() : []);
-    });
-    const sessionTemplate = new ResourceTemplate('jshook://instrumentation/session/{sessionId}', {
-        list: async () => {
-            const manager = getSessionManager(ctx);
-            return {
-                resources: (manager?.listSessions() ?? []).map((session) => ({
-                    name: session.name || `Instrumentation Session ${session.id}`,
-                    uri: `jshook://instrumentation/session/${session.id}`,
-                    mimeType: 'application/json',
-                    description: `operations=${session.operationCount}, artifacts=${session.artifactCount}, status=${session.status}`,
-                })),
-            };
-        },
-        complete: {
-            sessionId: async () => {
-                const manager = getSessionManager(ctx);
-                return (manager?.listSessions() ?? []).map((session) => session.id);
-            },
-        },
-    });
-    ctx.server.registerResource('instrumentation_session_snapshot', sessionTemplate, {
-        title: 'Instrumentation Session Snapshot',
-        description: 'Expanded snapshot for a single instrumentation session.',
-        mimeType: 'application/json',
-    }, async (uri, variables) => {
-        const sessionId = String(variables['sessionId'] ?? '');
-        const manager = getSessionManager(ctx);
-        const snapshot = manager?.getSessionSnapshot(sessionId);
-        return asJsonResource(uri.toString(), snapshot ?? {
-            success: false,
-            error: `Instrumentation session "${sessionId}" not found`,
-        });
-    });
-}

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

@@ -1,2 +0,0 @@
-import { z } from 'zod';
-export declare function buildZodShape(inputSchema: Record<string, unknown>): Record<string, z.ZodTypeAny>;

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

@@ -1,74 +0,0 @@
-import { z } from 'zod';
-function jsonSchemaToZod(prop) {
-    const schemaType = prop.type;
-    const description = typeof prop.description === 'string' ? prop.description : undefined;
-    let zodType;
-    switch (schemaType) {
-        case 'string':
-            if (Array.isArray(prop.enum)) {
-                const vals = prop.enum;
-                zodType = z.enum(vals);
-            }
-            else {
-                let str = z.string();
-                if (typeof prop.pattern === 'string') {
-                    str = str.regex(new RegExp(prop.pattern));
-                }
-                zodType = str;
-            }
-            break;
-        case 'number':
-        case 'integer': {
-            let num = z.number();
-            if (typeof prop.minimum === 'number')
-                num = num.min(prop.minimum);
-            if (typeof prop.maximum === 'number')
-                num = num.max(prop.maximum);
-            if (schemaType === 'integer')
-                num = num.int();
-            zodType = num;
-            break;
-        }
-        case 'boolean':
-            zodType = z.boolean();
-            break;
-        case 'array':
-            if (prop.items && typeof prop.items === 'object') {
-                zodType = z.array(jsonSchemaToZod(prop.items));
-            }
-            else {
-                zodType = z.array(z.unknown());
-            }
-            break;
-        case 'object':
-            if (prop.properties && typeof prop.properties === 'object') {
-                const nested = {};
-                const nestedRequired = new Set(Array.isArray(prop.required) ? prop.required : []);
-                for (const [k, v] of Object.entries(prop.properties)) {
-                    const field = jsonSchemaToZod(v);
-                    nested[k] = nestedRequired.has(k) ? field : field.optional();
-                }
-                zodType = z.object(nested);
-            }
-            else {
-                zodType = z.record(z.string(), z.unknown());
-            }
-            break;
-        default:
-            zodType = z.unknown();
-    }
-    if (description) {
-        zodType = zodType.describe(description);
-    }
-    return zodType;
-}
-export function buildZodShape(inputSchema) {
-    const props = inputSchema.properties ?? {};
-    const requiredKeys = new Set(Array.isArray(inputSchema.required) ? inputSchema.required : []);
-    const shape = {};
-    for (const [key, descriptor] of Object.entries(props)) {
-        const zodType = jsonSchemaToZod(descriptor && typeof descriptor === 'object' ? descriptor : {});
-        shape[key] = requiredKeys.has(key) ? zodType : zodType.optional();
-    }
-    return shape;
-}

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

@@ -1,4 +0,0 @@
-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;

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

@@ -1,12 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-interface ActivationSummary {
-    activated: string[];
-    alreadyActive: string[];
-    notFound: string[];
-    totalActive: number;
-}
-export declare function activateToolNames(ctx: MCPServerContext, names: string[]): Promise<ActivationSummary>;
-export declare function handleActivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
-export declare function handleDeactivateTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
-export {};

package/dist/src/server/MCPServer.search.handlers.activate.js

@@ -1,120 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { asTextResponse } from './domains/shared/response.js';
-import { getToolDomain } from './ToolCatalog.js';
-import { createToolHandlerMap } from './ToolHandlerMap.js';
-import { normalizeToolName, validateToolNameArray } from './MCPServer.search.validation.js';
-import { getActiveToolNames, getToolByName } from './MCPServer.search.helpers.js';
-async function notifyToolListChanged(ctx, changed) {
-    if (!changed) {
-        return;
-    }
-    try {
-        await ctx.server.sendToolListChanged();
-    }
-    catch (e) {
-        logger.warn('sendToolListChanged failed:', e);
-    }
-}
-export async function activateToolNames(ctx, names) {
-    const activeNames = getActiveToolNames(ctx);
-    const activated = [];
-    const alreadyActive = [];
-    const notFound = [];
-    for (const rawName of names) {
-        const name = normalizeToolName(rawName);
-        if (activeNames.has(name)) {
-            alreadyActive.push(name);
-            continue;
-        }
-        const toolDef = getToolByName(ctx).get(name);
-        if (!toolDef) {
-            notFound.push(name);
-            continue;
-        }
-        const registeredTool = ctx.registerSingleTool(toolDef);
-        ctx.activatedToolNames.add(name);
-        ctx.activatedRegisteredTools.set(name, registeredTool);
-        const extensionRecord = ctx.extensionToolsByName.get(name);
-        if (extensionRecord) {
-            extensionRecord.registeredTool = registeredTool;
-        }
-        const domain = getToolDomain(name) ?? ctx.extensionToolsByName.get(name)?.domain;
-        if (domain) {
-            ctx.enabledDomains.add(domain);
-        }
-        if (extensionRecord?.handler) {
-            ctx.router.addHandlers({
-                [name]: extensionRecord.handler,
-            });
-        }
-        else {
-            const newToolNames = new Set([name]);
-            const newHandlers = createToolHandlerMap(ctx.handlerDeps, newToolNames);
-            ctx.router.addHandlers(newHandlers);
-        }
-        activated.push(name);
-        activeNames.add(name);
-    }
-    await notifyToolListChanged(ctx, activated.length > 0);
-    logger.info(`activate_tools: activated ${activated.length}, already_active ${alreadyActive.length}, not_found ${notFound.length}`);
-    return {
-        activated,
-        alreadyActive,
-        notFound,
-        totalActive: activeNames.size,
-    };
-}
-export async function handleActivateTools(ctx, args) {
-    const { names, error } = validateToolNameArray(args);
-    if (error) {
-        return asTextResponse(JSON.stringify({ success: false, error }));
-    }
-    const result = await activateToolNames(ctx, names);
-    return asTextResponse(JSON.stringify({
-        success: true,
-        ...result,
-        hint: result.activated.length > 0
-            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
-            : undefined,
-    }));
-}
-export async function handleDeactivateTools(ctx, args) {
-    const { names, error } = validateToolNameArray(args);
-    if (error) {
-        return asTextResponse(JSON.stringify({ success: false, error }));
-    }
-    const deactivated = [];
-    const notActivated = [];
-    for (const rawName of names) {
-        const name = normalizeToolName(rawName);
-        if (!ctx.activatedToolNames.has(name)) {
-            notActivated.push(name);
-            continue;
-        }
-        const registeredTool = ctx.activatedRegisteredTools.get(name);
-        if (registeredTool) {
-            try {
-                registeredTool.remove();
-            }
-            catch (e) {
-                logger.warn(`Failed to remove activated tool "${name}":`, e);
-            }
-        }
-        ctx.router.removeHandler(name);
-        ctx.activatedToolNames.delete(name);
-        ctx.activatedRegisteredTools.delete(name);
-        const extensionRecord = ctx.extensionToolsByName.get(name);
-        if (extensionRecord) {
-            extensionRecord.registeredTool = undefined;
-        }
-        deactivated.push(name);
-    }
-    await notifyToolListChanged(ctx, deactivated.length > 0);
-    logger.info(`deactivate_tools: deactivated ${deactivated.length}, not_activated ${notActivated.length}`);
-    return asTextResponse(JSON.stringify({
-        success: true,
-        deactivated,
-        notActivated,
-        hint: 'Deactivated tools are no longer available. Search again to find alternatives.',
-    }));
-}

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

@@ -1,3 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-export declare function handleCallTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

package/dist/src/server/MCPServer.search.handlers.call.js

@@ -1,92 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { asTextResponse } from './domains/shared/response.js';
-import { normalizeToolName } from './MCPServer.search.validation.js';
-import { getToolByName, getSearchEngine } from './MCPServer.search.helpers.js';
-import { activateToolNames } from './MCPServer.search.handlers.activate.js';
-function buildCallToolMetadata(wasAutoActivated, activatedTools) {
-    return {
-        wasAutoActivated,
-        activatedTools,
-    };
-}
-function attachCallToolMetadata(response, metadata) {
-    return {
-        ...response,
-        content: response.content.map((item) => {
-            if (item.type !== 'text' || !('text' in item) || typeof item.text !== 'string') {
-                return item;
-            }
-            try {
-                const parsed = JSON.parse(item.text);
-                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-                    return item;
-                }
-                return {
-                    ...item,
-                    text: JSON.stringify({
-                        ...parsed,
-                        ...metadata,
-                    }, null, 2),
-                };
-            }
-            catch {
-                return item;
-            }
-        }),
-    };
-}
-export async function handleCallTool(ctx, args) {
-    const rawName = typeof args.name === 'string' ? args.name : '';
-    const defaultMetadata = buildCallToolMetadata(false, []);
-    if (!rawName) {
-        return asTextResponse(JSON.stringify({
-            success: false,
-            error: 'name must be a non-empty string',
-            ...defaultMetadata,
-        }));
-    }
-    const name = normalizeToolName(rawName);
-    const toolArgs = args.args && typeof args.args === 'object' && !Array.isArray(args.args)
-        ? args.args
-        : {};
-    let callMetadata = defaultMetadata;
-    if (!ctx.router.has(name)) {
-        const toolDef = getToolByName(ctx).get(name);
-        if (!toolDef) {
-            return asTextResponse(JSON.stringify({
-                success: false,
-                error: `Tool "${name}" not found in the catalogue. Use search_tools to discover available tools.`,
-                ...callMetadata,
-            }));
-        }
-        logger.info(`call_tool: auto-activating "${name}" (not in router)`);
-        const activation = await activateToolNames(ctx, [name]);
-        callMetadata = buildCallToolMetadata(true, activation.activated);
-        if (activation.activated.length === 0 && activation.alreadyActive.length === 0) {
-            return asTextResponse(JSON.stringify({
-                success: false,
-                error: `Tool "${name}" exists but could not be activated.`,
-                ...callMetadata,
-            }));
-        }
-    }
-    try {
-        const response = await ctx.executeToolWithTracking(name, toolArgs);
-        try {
-            const engine = getSearchEngine(ctx);
-            engine.recordToolCallFeedback(name, '');
-        }
-        catch {
-        }
-        return attachCallToolMetadata(response, callMetadata);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`call_tool: execution of "${name}" failed`, error);
-        return asTextResponse(JSON.stringify({
-            success: false,
-            error: `Tool "${name}" failed: ${message}`,
-            ...callMetadata,
-        }));
-    }
-}

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

@@ -1,3 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-export declare function handleActivateDomain(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

package/dist/src/server/MCPServer.search.handlers.domain.js

@@ -1,80 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { asTextResponse } from './domains/shared/response.js';
-import { getToolsByDomains } from './ToolCatalog.js';
-import { createToolHandlerMap } from './ToolHandlerMap.js';
-import { getAllDomains } from './registry/index.js';
-import { getActiveToolNames } from './MCPServer.search.helpers.js';
-import { startDomainTtl } from './MCPServer.activation.ttl.js';
-import { ACTIVATION_TTL_MINUTES } from '../constants.js';
-export async function handleActivateDomain(ctx, args) {
-    const domain = typeof args.domain === 'string' ? args.domain : '';
-    if (!domain) {
-        return asTextResponse(JSON.stringify({ success: false, error: 'domain must be a non-empty string' }));
-    }
-    const validDomains = new Set(getAllDomains());
-    for (const record of ctx.extensionToolsByName.values()) {
-        validDomains.add(record.domain);
-    }
-    if (!validDomains.has(domain)) {
-        return asTextResponse(JSON.stringify({
-            success: false,
-            error: `Unknown domain "${domain}". Valid: ${[...validDomains].join(', ')}`,
-        }));
-    }
-    const ttlMinutes = typeof args.ttlMinutes === 'number' ? args.ttlMinutes : ACTIVATION_TTL_MINUTES;
-    const domainTools = [
-        ...getToolsByDomains([domain]),
-        ...[...ctx.extensionToolsByName.values()]
-            .filter((record) => record.domain === domain)
-            .map((record) => record.tool),
-    ];
-    const activeNames = getActiveToolNames(ctx);
-    const activated = [];
-    ctx.enabledDomains.add(domain);
-    for (const toolDef of domainTools) {
-        if (activeNames.has(toolDef.name))
-            continue;
-        const registeredTool = ctx.registerSingleTool(toolDef);
-        ctx.activatedToolNames.add(toolDef.name);
-        ctx.activatedRegisteredTools.set(toolDef.name, registeredTool);
-        const extensionRecord = ctx.extensionToolsByName.get(toolDef.name);
-        if (extensionRecord) {
-            extensionRecord.registeredTool = registeredTool;
-        }
-        activated.push(toolDef.name);
-    }
-    if (activated.length > 0) {
-        const builtinNames = new Set(activated.filter((n) => !ctx.extensionToolsByName.has(n)));
-        if (builtinNames.size > 0) {
-            const newHandlers = createToolHandlerMap(ctx.handlerDeps, builtinNames);
-            ctx.router.addHandlers(newHandlers);
-        }
-        for (const name of activated) {
-            const extRecord = ctx.extensionToolsByName.get(name);
-            if (extRecord?.handler) {
-                ctx.router.addHandlers({
-                    [name]: extRecord.handler,
-                });
-            }
-        }
-        startDomainTtl(ctx, domain, ttlMinutes, activated);
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed:', e);
-        }
-    }
-    logger.info(`activate_domain: domain="${domain}", activated ${activated.length} tools, ttl=${ttlMinutes}min`);
-    return asTextResponse(JSON.stringify({
-        success: true,
-        domain,
-        activated: activated.length,
-        activatedTools: activated,
-        totalDomainTools: domainTools.length,
-        ttlMinutes: ttlMinutes > 0 ? ttlMinutes : 'no expiry',
-        hint: activated.length > 0
-            ? 'Tools activated. If they do not appear in your tool list, use call_tool({ name: "<tool>", args: {...} }) to invoke them.'
-            : undefined,
-    }));
-}

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

@@ -1,4 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-export declare function handleExtensionsReload(ctx: MCPServerContext): Promise<ToolResponse>;
-export declare function handleExtensionsList(ctx: MCPServerContext): Promise<ToolResponse>;

package/dist/src/server/MCPServer.search.handlers.extensions.js

@@ -1,9 +0,0 @@
-import { asTextResponse } from './domains/shared/response.js';
-export async function handleExtensionsReload(ctx) {
-    const result = await ctx.reloadExtensions();
-    return asTextResponse(JSON.stringify(result, null, 2));
-}
-export async function handleExtensionsList(ctx) {
-    const result = ctx.listExtensions();
-    return asTextResponse(JSON.stringify(result, null, 2));
-}

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

@@ -1,4 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-export declare function handleRouteTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;
-export declare function handleDescribeTool(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;

package/dist/src/server/MCPServer.search.handlers.route.js

@@ -1,85 +0,0 @@
-import { asTextResponse } from './domains/shared/response.js';
-import { buildCallToolCommand, routeToolRequest, describeTool } from './ToolRouter.js';
-import { activateToolNames } from './MCPServer.search.handlers.activate.js';
-import { handleActivateDomain } from './MCPServer.search.handlers.domain.js';
-import { getSearchEngine } from './MCPServer.search.helpers.js';
-import { ACTIVATION_TTL_MINUTES } from '../constants.js';
-function populateCallCommands(response) {
-    return {
-        ...response,
-        recommendations: response.recommendations.map((recommendation) => ({
-            ...recommendation,
-            callCommand: recommendation.callCommand ??
-                buildCallToolCommand(recommendation.name, recommendation.inputSchema),
-        })),
-    };
-}
-export async function handleRouteTool(ctx, args) {
-    const task = args.task;
-    const context = args.context;
-    if (!task || typeof task !== 'string') {
-        return asTextResponse(JSON.stringify({ success: false, error: 'task must be a non-empty string' }));
-    }
-    const engine = getSearchEngine(ctx);
-    const autoActivate = context?.autoActivate !== false;
-    let response = populateCallCommands(await routeToolRequest({ task, context }, ctx, engine));
-    if (autoActivate) {
-        const inactiveRecs = response.recommendations.filter((recommendation) => !recommendation.isActive);
-        if (inactiveRecs.length > 0) {
-            const domainsToActivate = new Set();
-            const toolsWithoutDomain = [];
-            for (const rec of inactiveRecs) {
-                if (rec.domain && !ctx.enabledDomains.has(rec.domain)) {
-                    domainsToActivate.add(rec.domain);
-                }
-                else if (!rec.domain) {
-                    toolsWithoutDomain.push(rec.name);
-                }
-            }
-            let activated = false;
-            for (const domain of domainsToActivate) {
-                try {
-                    await handleActivateDomain(ctx, {
-                        domain,
-                        ttlMinutes: ACTIVATION_TTL_MINUTES,
-                    });
-                    activated = true;
-                }
-                catch {
-                }
-            }
-            const remainingInactive = inactiveRecs
-                .filter((rec) => !domainsToActivate.has(rec.domain ?? ''))
-                .map((rec) => rec.name);
-            if (remainingInactive.length > 0 || toolsWithoutDomain.length > 0) {
-                const names = [...new Set([...remainingInactive, ...toolsWithoutDomain])];
-                const activation = await activateToolNames(ctx, names);
-                if (activation.activated.length > 0) {
-                    activated = true;
-                }
-            }
-            if (activated) {
-                response = populateCallCommands(await routeToolRequest({ task, context: { ...context, autoActivate: false } }, ctx, engine));
-                response.autoActivated = true;
-                response.activatedNames = inactiveRecs
-                    .map((r) => r.name)
-                    .filter((name) => ctx.activatedToolNames.has(name));
-                response.callToolHint =
-                    'Tools were auto-activated but may not appear in your tool list. ' +
-                        'Use call_tool({ name: "<tool_name>", args: {...} }) to invoke them directly.';
-            }
-        }
-    }
-    return asTextResponse(JSON.stringify(response, null, 2));
-}
-export async function handleDescribeTool(ctx, args) {
-    const name = args.name;
-    if (!name || typeof name !== 'string') {
-        return asTextResponse(JSON.stringify({ success: false, error: 'name must be a non-empty string' }));
-    }
-    const toolInfo = describeTool(name, ctx);
-    if (!toolInfo) {
-        return asTextResponse(JSON.stringify({ success: false, error: `Tool not found: ${name}` }));
-    }
-    return asTextResponse(JSON.stringify({ success: true, tool: toolInfo }, null, 2));
-}

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

@@ -1,3 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-import type { ToolResponse } from './types.js';
-export declare function handleSearchTools(ctx: MCPServerContext, args: Record<string, unknown>): Promise<ToolResponse>;