@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/server/domains/hooks/preset-handlers.js

@@ -1,154 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { PRESETS, PRESET_LIST } from '../../domains/hooks/preset-definitions.js';
-import { buildHookCode } from '../../domains/hooks/preset-builder.js';
-import { argBool, argString, argStringArray } from '../../domains/shared/parse-args.js';
-export class HookPresetToolHandlers {
-    pageController;
-    constructor(pageController) {
-        this.pageController = pageController;
-    }
-    async handleHookPreset(args) {
-        try {
-            const customPresetMap = this.buildCustomPresetMap(args);
-            const availablePresets = {
-                ...PRESETS,
-                ...customPresetMap,
-            };
-            const availablePresetList = [
-                ...PRESET_LIST,
-                ...Object.entries(customPresetMap).map(([id, preset]) => ({
-                    id,
-                    description: `${preset.description} (custom)`,
-                })),
-            ];
-            if (args.listPresets === true) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                totalPresets: availablePresetList.length,
-                                presets: availablePresetList,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const captureStack = argBool(args, 'captureStack', false);
-            const logToConsole = argBool(args, 'logToConsole', true);
-            const method = argString(args, 'method', 'evaluate');
-            let targets = [];
-            if (args.preset) {
-                targets = [argString(args, 'preset')];
-            }
-            else if (Array.isArray(args.presets)) {
-                targets = argStringArray(args, 'presets');
-            }
-            else {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: ' Provide either preset (single) or presets (multiple), or set listPresets=true to list available presets',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const invalid = targets.filter((t) => !availablePresets[t]);
-            if (invalid.length > 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: `: ${invalid.join(', ')}`,
-                                availablePresets: availablePresetList.map((p) => p.id),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const page = await this.pageController.getPage();
-            const injected = [];
-            const errors = [];
-            for (const presetId of targets) {
-                try {
-                    const code = availablePresets[presetId].buildCode(captureStack, logToConsole);
-                    if (method === 'evaluateOnNewDocument') {
-                        await page.evaluateOnNewDocument(code);
-                    }
-                    else {
-                        await page.evaluate(code);
-                    }
-                    injected.push(presetId);
-                    logger.info(` Hook preset injected: ${presetId}`);
-                }
-                catch (err) {
-                    const errorMessage = err instanceof Error ? err.message : String(err);
-                    errors.push({ preset: presetId, error: errorMessage });
-                    logger.error(` Failed to inject preset ${presetId}:`, err);
-                }
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: errors.length === 0,
-                            injected,
-                            failed: errors,
-                            method,
-                            captureStack,
-                            message: ` ${injected.length}/${targets.length}  Hook`,
-                            usage: ` ai_hook_get_data(hookId: "preset-<>") `,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Hook preset injection failed', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    buildCustomPresetMap(args) {
-        const rawTemplates = [];
-        if (args.customTemplate && typeof args.customTemplate === 'object') {
-            rawTemplates.push(args.customTemplate);
-        }
-        if (Array.isArray(args.customTemplates)) {
-            rawTemplates.push(...args.customTemplates);
-        }
-        const customPresets = {};
-        for (const template of rawTemplates) {
-            const id = template.id?.trim();
-            const body = template.body?.trim();
-            if (!id || !body) {
-                throw new Error('Each custom template requires non-empty id and body');
-            }
-            if (PRESETS[id]) {
-                throw new Error(`Custom template id conflicts with built-in preset: ${id}`);
-            }
-            customPresets[id] = {
-                description: template.description?.trim() || `Custom inline preset: ${id}`,
-                buildCode: (captureStack, logToConsole) => buildHookCode(id, body, captureStack, logToConsole),
-            };
-        }
-        return customPresets;
-    }
-}

package/dist/src/server/domains/instrumentation/definitions.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const instrumentationTools: Tool[];

package/dist/src/server/domains/instrumentation/definitions.js

@@ -1,99 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-const queryTypes = [
-    'before-load-inject',
-    'runtime-hook',
-    'network-intercept',
-    'function-trace',
-];
-export const instrumentationTools = [
-    tool('instrumentation_session_create')
-        .desc('Create a new instrumentation session that groups hooks, intercepts, and traces into a single queryable container.\n\nAll subsequent instrumentation operations can be associated with this session for unified management and artifact export.')
-        .string('name', 'Optional human-readable name for the session')
-        .build(),
-    tool('instrumentation_session_list')
-        .desc('List all active instrumentation sessions with their operation and artifact counts.')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('instrumentation_session_destroy')
-        .desc('Destroy an instrumentation session, marking all its operations as completed. Session data is retained for querying but no new operations can be added.')
-        .string('sessionId', 'Session ID returned by instrumentation_session_create')
-        .required('sessionId')
-        .destructive()
-        .idempotent()
-        .build(),
-    tool('instrumentation_session_status')
-        .desc('Get detailed status for an instrumentation session including operation count, artifact count, and active/destroyed state.')
-        .string('sessionId', 'Session ID')
-        .required('sessionId')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('instrumentation_operation_register')
-        .desc('Register a new instrumentation operation within a session so hooks, intercepts, and traces become queryable evidence-producing work items.')
-        .string('sessionId', 'Session ID returned by instrumentation_session_create')
-        .enum('type', queryTypes, 'Instrumentation type to register')
-        .string('target', 'Function name, URL pattern, or script target for the operation')
-        .object('config', {}, 'Operation-specific configuration payload')
-        .required('sessionId', 'type', 'target')
-        .build(),
-    tool('instrumentation_operation_list')
-        .desc('List all operations (hooks, intercepts, traces) registered within a session, optionally filtered by type.')
-        .string('sessionId', 'Session ID')
-        .enum('type', queryTypes, 'Optional filter by instrumentation type')
-        .required('sessionId')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('instrumentation_artifact_record')
-        .desc('Record a captured artifact for an instrumentation operation so the session and evidence graph reflect observed runtime data.')
-        .string('operationId', 'Operation ID returned by instrumentation_operation_register')
-        .object('data', {}, 'Captured artifact payload such as args, returnValue, headers, or body')
-        .required('operationId', 'data')
-        .build(),
-    tool('instrumentation_artifact_query')
-        .desc('Query captured artifacts (args, return values, intercepted requests, trace data) from a session, optionally filtered by type and limited.')
-        .string('sessionId', 'Session ID')
-        .enum('type', queryTypes, 'Optional filter by artifact type')
-        .number('limit', 'Maximum number of artifacts to return', { default: 50 })
-        .required('sessionId')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('instrumentation_hook_preset')
-        .desc('Apply hooks domain preset hooks within an instrumentation session and persist the injected preset summary as session artifacts.')
-        .string('sessionId', 'Session ID returned by instrumentation_session_create')
-        .string('preset', 'Single preset id to inject')
-        .array('presets', { type: 'string' }, 'Multiple preset ids to inject in one call')
-        .boolean('captureStack', 'Whether injected presets should capture stack traces', {
-        default: false,
-    })
-        .boolean('logToConsole', 'Whether injected presets should log to console', { default: true })
-        .enum('method', ['evaluate', 'evaluateOnNewDocument'], 'Injection method forwarded to hook_preset', { default: 'evaluate' })
-        .prop('customTemplate', {
-        type: 'object',
-        additionalProperties: true,
-        description: 'Optional inline custom preset definition',
-    })
-        .prop('customTemplates', {
-        type: 'array',
-        items: { type: 'object', additionalProperties: true },
-        description: 'Optional inline custom preset definitions',
-    })
-        .required('sessionId')
-        .openWorld()
-        .build(),
-    tool('instrumentation_network_replay')
-        .desc('Replay a previously captured network request inside an instrumentation session and persist the replay result or dry-run preview as session artifacts.')
-        .string('sessionId', 'Session ID returned by instrumentation_session_create')
-        .string('requestId', 'Captured request ID returned by network_get_requests')
-        .object('headerPatch', { additionalProperties: { type: 'string' } }, 'Optional request header overrides')
-        .string('bodyPatch', 'Optional raw request body override')
-        .string('methodOverride', 'Optional HTTP method override')
-        .string('urlOverride', 'Optional destination URL override')
-        .number('timeoutMs', 'Optional replay timeout in milliseconds')
-        .boolean('dryRun', 'Preview the replay without sending the request', { default: true })
-        .required('sessionId', 'requestId')
-        .openWorld()
-        .build(),
-];

package/dist/src/server/domains/instrumentation/handlers.d.ts

@@ -1,78 +0,0 @@
-import type { InstrumentationSessionManager } from '../../instrumentation/InstrumentationSession.js';
-import type { ToolResponse } from '../../types.js';
-interface HookPresetHandlerLike {
-    handleHookPreset(args: Record<string, unknown>): Promise<ToolResponse>;
-}
-interface NetworkReplayHandlerLike {
-    handleNetworkReplayRequest(args: Record<string, unknown>): Promise<ToolResponse>;
-}
-interface InstrumentationHandlerDeps {
-    hookPresetHandlers?: HookPresetHandlerLike;
-    advancedHandlers?: NetworkReplayHandlerLike;
-}
-export declare class InstrumentationHandlers {
-    private readonly sessionManager;
-    private readonly deps;
-    constructor(sessionManager: InstrumentationSessionManager, deps?: InstrumentationHandlerDeps);
-    handleSessionCreate(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleSessionList(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleSessionDestroy(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleSessionStatus(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleOperationList(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleOperationRegister(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleArtifactQuery(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleArtifactRecord(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleHookPreset(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleNetworkReplay(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}
-export {};

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

@@ -1,206 +0,0 @@
-import { InstrumentationType } from '../../instrumentation/types.js';
-import { argString } from '../../domains/shared/parse-args.js';
-function jsonResponse(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-    };
-}
-export class InstrumentationHandlers {
-    sessionManager;
-    deps;
-    constructor(sessionManager, deps = {}) {
-        this.sessionManager = sessionManager;
-        this.deps = deps;
-    }
-    async handleSessionCreate(args) {
-        try {
-            const name = argString(args, 'name');
-            const session = this.sessionManager.createSession(name || undefined);
-            return jsonResponse({ success: true, session });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleSessionList(_args) {
-        try {
-            const sessions = this.sessionManager.listSessions();
-            return jsonResponse({ success: true, totalSessions: sessions.length, sessions });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleSessionDestroy(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            this.sessionManager.destroySession(sessionId);
-            return jsonResponse({ success: true, sessionId, message: 'Session destroyed' });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleSessionStatus(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            const session = this.sessionManager.getSession(sessionId);
-            if (!session)
-                return jsonResponse({ success: false, error: `Session "${sessionId}" not found` });
-            const stats = this.sessionManager.getSessionStats(sessionId);
-            return jsonResponse({ success: true, session, stats });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleOperationList(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            let ops = this.sessionManager.getSessionOperations(sessionId);
-            const typeFilter = argString(args, 'type');
-            if (typeFilter) {
-                ops = ops.filter((o) => o.type === typeFilter);
-            }
-            return jsonResponse({ success: true, totalOperations: ops.length, operations: ops });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleOperationRegister(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            const type = argString(args, 'type', '');
-            const target = argString(args, 'target', '');
-            const config = args.config && typeof args.config === 'object' && !Array.isArray(args.config)
-                ? args.config
-                : {};
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            if (!type)
-                return jsonResponse({ success: false, error: 'type is required' });
-            if (!target)
-                return jsonResponse({ success: false, error: 'target is required' });
-            const operation = this.sessionManager.registerOperation(sessionId, type, target, config);
-            return jsonResponse({ success: true, operation });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleArtifactQuery(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            const typeRaw = argString(args, 'type');
-            const type = typeRaw ? typeRaw : undefined;
-            const limit = typeof args.limit === 'number' ? args.limit : 50;
-            let artifacts = this.sessionManager.getArtifacts(sessionId, type);
-            if (limit > 0)
-                artifacts = artifacts.slice(0, limit);
-            return jsonResponse({ success: true, totalArtifacts: artifacts.length, artifacts });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleArtifactRecord(args) {
-        try {
-            const operationId = argString(args, 'operationId', '');
-            const data = args.data && typeof args.data === 'object' && !Array.isArray(args.data)
-                ? args.data
-                : undefined;
-            if (!operationId)
-                return jsonResponse({ success: false, error: 'operationId is required' });
-            if (!data)
-                return jsonResponse({ success: false, error: 'data is required' });
-            const artifact = this.sessionManager.recordArtifact(operationId, data);
-            return jsonResponse({ success: true, artifact });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleHookPreset(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            if (!this.deps.hookPresetHandlers) {
-                return jsonResponse({ success: false, error: 'hookPresetHandlers is not available' });
-            }
-            const delegatedArgs = { ...args };
-            delete delegatedArgs['sessionId'];
-            const result = await this.sessionManager.applyHookPreset(sessionId, this.deps.hookPresetHandlers, delegatedArgs);
-            return jsonResponse({
-                success: result.payload.success !== false && result.operation.status === 'completed',
-                operation: result.operation,
-                artifacts: result.artifacts,
-                result: result.payload,
-            });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async handleNetworkReplay(args) {
-        try {
-            const sessionId = argString(args, 'sessionId', '');
-            if (!sessionId)
-                return jsonResponse({ success: false, error: 'sessionId is required' });
-            if (!this.deps.advancedHandlers) {
-                return jsonResponse({ success: false, error: 'advancedHandlers is not available' });
-            }
-            const delegatedArgs = { ...args };
-            delete delegatedArgs['sessionId'];
-            const result = await this.sessionManager.replayNetworkRequest(sessionId, this.deps.advancedHandlers, delegatedArgs);
-            return jsonResponse({
-                success: result.payload.success !== false && result.operation.status === 'completed',
-                operation: result.operation,
-                artifacts: result.artifacts,
-                result: result.payload,
-            });
-        }
-        catch (error) {
-            return jsonResponse({
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-}

package/dist/src/server/domains/instrumentation/index.d.ts

@@ -1,2 +0,0 @@
-export { InstrumentationHandlers } from './handlers.js';
-export { instrumentationTools } from './definitions.js';

package/dist/src/server/domains/instrumentation/index.js

@@ -1,2 +0,0 @@
-export { InstrumentationHandlers } from './handlers.js';
-export { instrumentationTools } from './definitions.js';

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

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