@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,178 +0,0 @@
-import { DebuggerControlHandlers } from '../../domains/debugger/handlers/debugger-control.js';
-import { DebuggerSteppingHandlers } from '../../domains/debugger/handlers/debugger-stepping.js';
-import { DebuggerEvaluateHandlers } from '../../domains/debugger/handlers/debugger-evaluate.js';
-import { DebuggerStateHandlers } from '../../domains/debugger/handlers/debugger-state.js';
-import { SessionManagementHandlers } from '../../domains/debugger/handlers/session-management.js';
-import { BreakpointBasicHandlers } from '../../domains/debugger/handlers/breakpoint-basic.js';
-import { BreakpointExceptionHandlers } from '../../domains/debugger/handlers/breakpoint-exception.js';
-import { XHRBreakpointHandlers } from '../../domains/debugger/handlers/xhr-breakpoint.js';
-import { EventBreakpointHandlers } from '../../domains/debugger/handlers/event-breakpoint.js';
-import { WatchExpressionsHandlers } from '../../domains/debugger/handlers/watch-expressions.js';
-import { ScopeInspectionHandlers } from '../../domains/debugger/handlers/scope-inspection.js';
-import { BlackboxHandlers } from '../../domains/debugger/handlers/blackbox-handlers.js';
-export class DebuggerToolHandlers {
-    debuggerManager;
-    runtimeInspector;
-    debuggerControl;
-    debuggerStepping;
-    debuggerEvaluate;
-    debuggerState;
-    sessionManagement;
-    breakpointBasic;
-    breakpointException;
-    xhrBreakpoint;
-    eventBreakpoint;
-    watchExpressions;
-    scopeInspection;
-    blackbox;
-    constructor(debuggerManager, runtimeInspector) {
-        this.debuggerManager = debuggerManager;
-        this.runtimeInspector = runtimeInspector;
-        const commonDeps = {
-            debuggerManager: this.debuggerManager,
-            runtimeInspector: this.runtimeInspector,
-        };
-        this.debuggerControl = new DebuggerControlHandlers(commonDeps);
-        this.debuggerStepping = new DebuggerSteppingHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.debuggerEvaluate = new DebuggerEvaluateHandlers({
-            runtimeInspector: this.runtimeInspector,
-        });
-        this.debuggerState = new DebuggerStateHandlers(commonDeps);
-        this.sessionManagement = new SessionManagementHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.breakpointBasic = new BreakpointBasicHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.breakpointException = new BreakpointExceptionHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.xhrBreakpoint = new XHRBreakpointHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.eventBreakpoint = new EventBreakpointHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.watchExpressions = new WatchExpressionsHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-        this.scopeInspection = new ScopeInspectionHandlers(commonDeps);
-        this.blackbox = new BlackboxHandlers({
-            debuggerManager: this.debuggerManager,
-        });
-    }
-    async handleDebuggerEnable(args) {
-        return this.debuggerControl.handleDebuggerEnable(args);
-    }
-    async handleDebuggerDisable(args) {
-        return this.debuggerControl.handleDebuggerDisable(args);
-    }
-    async handleDebuggerPause(args) {
-        return this.debuggerControl.handleDebuggerPause(args);
-    }
-    async handleDebuggerResume(args) {
-        return this.debuggerControl.handleDebuggerResume(args);
-    }
-    async handleDebuggerStepInto(args) {
-        return this.debuggerStepping.handleDebuggerStepInto(args);
-    }
-    async handleDebuggerStepOver(args) {
-        return this.debuggerStepping.handleDebuggerStepOver(args);
-    }
-    async handleDebuggerStepOut(args) {
-        return this.debuggerStepping.handleDebuggerStepOut(args);
-    }
-    async handleDebuggerEvaluate(args) {
-        return this.debuggerEvaluate.handleDebuggerEvaluate(args);
-    }
-    async handleDebuggerEvaluateGlobal(args) {
-        return this.debuggerEvaluate.handleDebuggerEvaluateGlobal(args);
-    }
-    async handleDebuggerWaitForPaused(args) {
-        return this.debuggerState.handleDebuggerWaitForPaused(args);
-    }
-    async handleDebuggerGetPausedState(args) {
-        return this.debuggerState.handleDebuggerGetPausedState(args);
-    }
-    async handleGetCallStack(args) {
-        return this.debuggerState.handleGetCallStack(args);
-    }
-    async handleSaveSession(args) {
-        return this.sessionManagement.handleSaveSession(args);
-    }
-    async handleLoadSession(args) {
-        return this.sessionManagement.handleLoadSession(args);
-    }
-    async handleExportSession(args) {
-        return this.sessionManagement.handleExportSession(args);
-    }
-    async handleListSessions(args) {
-        return this.sessionManagement.handleListSessions(args);
-    }
-    async handleBreakpointSet(args) {
-        return this.breakpointBasic.handleBreakpointSet(args);
-    }
-    async handleBreakpointRemove(args) {
-        return this.breakpointBasic.handleBreakpointRemove(args);
-    }
-    async handleBreakpointList(args) {
-        return this.breakpointBasic.handleBreakpointList(args);
-    }
-    async handleBreakpointSetOnException(args) {
-        return this.breakpointException.handleBreakpointSetOnException(args);
-    }
-    async handleXHRBreakpointSet(args) {
-        return this.xhrBreakpoint.handleXHRBreakpointSet(args);
-    }
-    async handleXHRBreakpointRemove(args) {
-        return this.xhrBreakpoint.handleXHRBreakpointRemove(args);
-    }
-    async handleXHRBreakpointList(args) {
-        return this.xhrBreakpoint.handleXHRBreakpointList(args);
-    }
-    async handleEventBreakpointSet(args) {
-        return this.eventBreakpoint.handleEventBreakpointSet(args);
-    }
-    async handleEventBreakpointSetCategory(args) {
-        return this.eventBreakpoint.handleEventBreakpointSetCategory(args);
-    }
-    async handleEventBreakpointRemove(args) {
-        return this.eventBreakpoint.handleEventBreakpointRemove(args);
-    }
-    async handleEventBreakpointList(args) {
-        return this.eventBreakpoint.handleEventBreakpointList(args);
-    }
-    async handleWatchAdd(args) {
-        return this.watchExpressions.handleWatchAdd(args);
-    }
-    async handleWatchRemove(args) {
-        return this.watchExpressions.handleWatchRemove(args);
-    }
-    async handleWatchList(args) {
-        return this.watchExpressions.handleWatchList(args);
-    }
-    async handleWatchEvaluateAll(args) {
-        return this.watchExpressions.handleWatchEvaluateAll(args);
-    }
-    async handleWatchClearAll(args) {
-        return this.watchExpressions.handleWatchClearAll(args);
-    }
-    async handleGetScopeVariablesEnhanced(args) {
-        return this.scopeInspection.handleGetScopeVariablesEnhanced(args);
-    }
-    async handleGetObjectProperties(args) {
-        return this.scopeInspection.handleGetObjectProperties(args);
-    }
-    async handleBlackboxAdd(args) {
-        return this.blackbox.handleBlackboxAdd(args);
-    }
-    async handleBlackboxAddCommon(args) {
-        return this.blackbox.handleBlackboxAddCommon(args);
-    }
-    async handleBlackboxList(args) {
-        return this.blackbox.handleBlackboxList(args);
-    }
-}
-export { DebuggerControlHandlers, DebuggerSteppingHandlers, DebuggerEvaluateHandlers, DebuggerStateHandlers, SessionManagementHandlers, BreakpointBasicHandlers, BreakpointExceptionHandlers, XHRBreakpointHandlers, EventBreakpointHandlers, WatchExpressionsHandlers, ScopeInspectionHandlers, BlackboxHandlers, };

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

@@ -1,2 +0,0 @@
-export { debuggerTools } from '../../domains/debugger/definitions.js';
-export { DebuggerToolHandlers } from '../../domains/debugger/handlers.js';

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

@@ -1,2 +0,0 @@
-export { debuggerTools } from '../../domains/debugger/definitions.js';
-export { DebuggerToolHandlers } from '../../domains/debugger/handlers.js';

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

@@ -1,67 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-import { DebuggerToolHandlers } from '../../domains/debugger/index.js';
-type H = DebuggerToolHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "debugger";
-    depKey: "debuggerHandlers";
-    profiles: ("workflow" | "full")[];
-    ensure: typeof ensure;
-    prerequisites: {
-        debugger_enable: {
-            condition: string;
-            fix: string;
-        }[];
-        breakpoint_set: {
-            condition: string;
-            fix: 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: "debugger";
-        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;

package/dist/src/server/domains/debugger/manifest.js

@@ -1,163 +0,0 @@
-import { bindByDepKey, ensureBrowserCore, toolLookup } from '../../domains/shared/registry.js';
-import { debuggerTools } from '../../domains/debugger/definitions.js';
-import { DebuggerToolHandlers } from '../../domains/debugger/index.js';
-import { DebuggerManager } from '../../domains/shared/modules.js';
-import { RuntimeInspector } from '../../domains/shared/modules.js';
-const DOMAIN = 'debugger';
-const DEP_KEY = 'debuggerHandlers';
-const t = toolLookup(debuggerTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    ensureBrowserCore(ctx);
-    if (!ctx.debuggerManager)
-        ctx.debuggerManager = new DebuggerManager(ctx.collector);
-    if (!ctx.runtimeInspector)
-        ctx.runtimeInspector = new RuntimeInspector(ctx.collector, ctx.debuggerManager);
-    if (!ctx.debuggerHandlers) {
-        ctx.debuggerHandlers = new DebuggerToolHandlers(ctx.debuggerManager, ctx.runtimeInspector);
-    }
-    return ctx.debuggerHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    prerequisites: {
-        debugger_enable: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        breakpoint_set: [
-            {
-                condition: 'Browser must be launched',
-                fix: 'Call browser_launch and debugger_enable first',
-            },
-        ],
-    },
-    registrations: [
-        { tool: t('debugger_enable'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerEnable(a)) },
-        { tool: t('debugger_disable'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerDisable(a)) },
-        { tool: t('debugger_pause'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerPause(a)) },
-        { tool: t('debugger_resume'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerResume(a)) },
-        {
-            tool: t('debugger_step_into'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerStepInto(a)),
-        },
-        {
-            tool: t('debugger_step_over'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerStepOver(a)),
-        },
-        { tool: t('debugger_step_out'), domain: DOMAIN, bind: b((h, a) => h.handleDebuggerStepOut(a)) },
-        { tool: t('breakpoint_set'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointSet(a)) },
-        {
-            tool: t('breakpoint_remove'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleBreakpointRemove(a)),
-        },
-        { tool: t('breakpoint_list'), domain: DOMAIN, bind: b((h, a) => h.handleBreakpointList(a)) },
-        { tool: t('get_call_stack'), domain: DOMAIN, bind: b((h, a) => h.handleGetCallStack(a)) },
-        {
-            tool: t('debugger_evaluate'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerEvaluate(a)),
-        },
-        {
-            tool: t('debugger_evaluate_global'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerEvaluateGlobal(a)),
-        },
-        {
-            tool: t('debugger_wait_for_paused'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerWaitForPaused(a)),
-        },
-        {
-            tool: t('debugger_get_paused_state'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDebuggerGetPausedState(a)),
-        },
-        {
-            tool: t('breakpoint_set_on_exception'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleBreakpointSetOnException(a)),
-        },
-        {
-            tool: t('get_object_properties'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleGetObjectProperties(a)),
-        },
-        {
-            tool: t('get_scope_variables_enhanced'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleGetScopeVariablesEnhanced(a)),
-        },
-        { tool: t('debugger_save_session'), domain: DOMAIN, bind: b((h, a) => h.handleSaveSession(a)) },
-        { tool: t('debugger_load_session'), domain: DOMAIN, bind: b((h, a) => h.handleLoadSession(a)) },
-        {
-            tool: t('debugger_export_session'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleExportSession(a)),
-        },
-        {
-            tool: t('debugger_list_sessions'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleListSessions(a)),
-        },
-        { tool: t('watch_add'), domain: DOMAIN, bind: b((h, a) => h.handleWatchAdd(a)) },
-        { tool: t('watch_remove'), domain: DOMAIN, bind: b((h, a) => h.handleWatchRemove(a)) },
-        { tool: t('watch_list'), domain: DOMAIN, bind: b((h, a) => h.handleWatchList(a)) },
-        {
-            tool: t('watch_evaluate_all'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleWatchEvaluateAll(a)),
-        },
-        { tool: t('watch_clear_all'), domain: DOMAIN, bind: b((h, a) => h.handleWatchClearAll(a)) },
-        {
-            tool: t('xhr_breakpoint_set'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleXHRBreakpointSet(a)),
-        },
-        {
-            tool: t('xhr_breakpoint_remove'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleXHRBreakpointRemove(a)),
-        },
-        {
-            tool: t('xhr_breakpoint_list'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleXHRBreakpointList(a)),
-        },
-        {
-            tool: t('event_breakpoint_set'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleEventBreakpointSet(a)),
-        },
-        {
-            tool: t('event_breakpoint_set_category'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleEventBreakpointSetCategory(a)),
-        },
-        {
-            tool: t('event_breakpoint_remove'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleEventBreakpointRemove(a)),
-        },
-        {
-            tool: t('event_breakpoint_list'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleEventBreakpointList(a)),
-        },
-        { tool: t('blackbox_add'), domain: DOMAIN, bind: b((h, a) => h.handleBlackboxAdd(a)) },
-        {
-            tool: t('blackbox_add_common'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleBlackboxAddCommon(a)),
-        },
-        { tool: t('blackbox_list'), domain: DOMAIN, bind: b((h, a) => h.handleBlackboxList(a)) },
-    ],
-};
-export default manifest;

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

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

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

@@ -1,45 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-export const encodingTools = [
-    tool('binary_detect_format')
-        .desc('Detect binary payload format/encoding via magic bytes, encoding heuristics, and Shannon entropy')
-        .string('data', 'Input payload')
-        .enum('source', ['base64', 'hex', 'file', 'raw'], 'How to interpret input payload')
-        .string('filePath', 'File path when source=file')
-        .string('requestId', 'Captured network requestId to resolve response body')
-        .required('source')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('binary_decode')
-        .desc('Decode binary payloads into hex, utf8, or json output')
-        .string('data', 'Input encoded payload')
-        .enum('encoding', ['base64', 'hex', 'url', 'protobuf', 'msgpack'], 'Declared input encoding')
-        .enum('outputFormat', ['hex', 'utf8', 'json'], 'Target output format', { default: 'hex' })
-        .required('data', 'encoding')
-        .build(),
-    tool('binary_encode')
-        .desc('Encode utf8/hex/json input into base64/hex/url output')
-        .string('data', 'Input payload')
-        .enum('inputFormat', ['utf8', 'hex', 'json'], 'How to parse input')
-        .enum('outputEncoding', ['base64', 'hex', 'url'], 'Desired output encoding')
-        .required('data', 'inputFormat', 'outputEncoding')
-        .build(),
-    tool('binary_entropy_analysis')
-        .desc('Compute Shannon entropy + byte frequency to assess plaintext/encoded/compressed/encrypted likelihood')
-        .string('data', 'Input payload')
-        .enum('source', ['base64', 'hex', 'raw', 'file'], 'How to interpret input payload')
-        .string('filePath', 'File path when source=file')
-        .number('blockSize', 'Block size for per-block entropy', { default: 256 })
-        .required('source')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('protobuf_decode_raw')
-        .desc('Decode base64 protobuf bytes without schema using wire-type aware recursive parser')
-        .string('data', 'Base64-encoded protobuf payload')
-        .number('maxDepth', 'Maximum recursive decode depth', { default: 5 })
-        .required('data')
-        .readOnly()
-        .idempotent()
-        .build(),
-];

package/dist/src/server/domains/encoding/encoding-msgpack.d.ts

@@ -1,7 +0,0 @@
-import type { MsgPackDecodeResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare function decodeMsgPack(buffer: Buffer): unknown;
-export declare function decodeMsgPackValue(buffer: Buffer, startOffset: number, depth: number): MsgPackDecodeResult;
-export declare function decodeMsgPackArray(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-export declare function decodeMsgPackMap(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-export declare function msgPackMapKey(value: unknown): string;
-export declare function ensureRange(buffer: Buffer, offset: number, length: number): void;