@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/domains/debugger/handlers/event-breakpoint.js

@@ -1,179 +0,0 @@
-import { argString } from '../../../domains/shared/parse-args.js';
-function hasEnsureAdvancedFeatures(manager) {
-    return (typeof manager.ensureAdvancedFeatures === 'function');
-}
-function getErrorMessage(error) {
-    if (typeof error === 'object' && error !== null && 'message' in error) {
-        const message = error.message;
-        if (typeof message === 'string' && message.length > 0) {
-            return message;
-        }
-    }
-    return String(error);
-}
-export class EventBreakpointHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async ensureAdvancedFeaturesIfSupported() {
-        if (hasEnsureAdvancedFeatures(this.deps.debuggerManager)) {
-            await this.deps.debuggerManager.ensureAdvancedFeatures();
-        }
-    }
-    async handleEventBreakpointSet(args) {
-        try {
-            const eventName = argString(args, 'eventName', '');
-            const targetName = argString(args, 'targetName');
-            await this.ensureAdvancedFeaturesIfSupported();
-            const eventManager = this.deps.debuggerManager.getEventManager();
-            const breakpointId = await eventManager.setEventListenerBreakpoint(eventName, targetName);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Event breakpoint set',
-                            breakpointId,
-                            eventName,
-                            targetName,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to set event breakpoint',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleEventBreakpointSetCategory(args) {
-        try {
-            const category = argString(args, 'category', '');
-            await this.ensureAdvancedFeaturesIfSupported();
-            const eventManager = this.deps.debuggerManager.getEventManager();
-            let breakpointIds;
-            switch (category) {
-                case 'mouse':
-                    breakpointIds = await eventManager.setMouseEventBreakpoints();
-                    break;
-                case 'keyboard':
-                    breakpointIds = await eventManager.setKeyboardEventBreakpoints();
-                    break;
-                case 'timer':
-                    breakpointIds = await eventManager.setTimerEventBreakpoints();
-                    break;
-                case 'websocket':
-                    breakpointIds = await eventManager.setWebSocketEventBreakpoints();
-                    break;
-                default:
-                    throw new Error(`Unknown category: ${category}`);
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Set ${breakpointIds.length} ${category} event breakpoint(s)`,
-                            category,
-                            breakpointIds,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to set event breakpoints',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleEventBreakpointRemove(args) {
-        try {
-            const breakpointId = argString(args, 'breakpointId', '');
-            await this.ensureAdvancedFeaturesIfSupported();
-            const eventManager = this.deps.debuggerManager.getEventManager();
-            const removed = await eventManager.removeEventListenerBreakpoint(breakpointId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: removed,
-                            message: removed ? 'Event breakpoint removed' : 'Event breakpoint not found',
-                            breakpointId,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to remove event breakpoint',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleEventBreakpointList(_args) {
-        try {
-            await this.ensureAdvancedFeaturesIfSupported();
-            const eventManager = this.deps.debuggerManager.getEventManager();
-            const breakpoints = eventManager.getAllEventBreakpoints();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Found ${breakpoints.length} event breakpoint(s)`,
-                            breakpoints,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to list event breakpoints',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/debugger/handlers/scope-inspection.d.ts

@@ -1,23 +0,0 @@
-import type { DebuggerManager } from '../../../domains/shared/modules.js';
-import type { RuntimeInspector } from '../../../domains/shared/modules.js';
-interface ScopeInspectionHandlersDeps {
-    debuggerManager: DebuggerManager;
-    runtimeInspector: RuntimeInspector;
-}
-export declare class ScopeInspectionHandlers {
-    private deps;
-    constructor(deps: ScopeInspectionHandlersDeps);
-    handleGetScopeVariablesEnhanced(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleGetObjectProperties(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

package/dist/src/server/domains/debugger/handlers/scope-inspection.js

@@ -1,100 +0,0 @@
-import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
-const getErrorMessage = (error, fallback) => {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === 'object' && error !== null && 'message' in error) {
-        const message = error.message;
-        if (typeof message === 'string') {
-            return message;
-        }
-    }
-    return fallback;
-};
-export class ScopeInspectionHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleGetScopeVariablesEnhanced(args) {
-        const callFrameId = argString(args, 'callFrameId');
-        const includeObjectProperties = argBool(args, 'includeObjectProperties');
-        const maxDepth = argNumber(args, 'maxDepth');
-        const skipErrors = argBool(args, 'skipErrors', true);
-        try {
-            const result = await this.deps.debuggerManager.getScopeVariables({
-                callFrameId,
-                includeObjectProperties,
-                maxDepth,
-                skipErrors,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: getErrorMessage(error, 'Failed to get scope variables'),
-                            error: String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleGetObjectProperties(args) {
-        const objectId = argString(args, 'objectId', '');
-        if (!objectId) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'objectId parameter is required',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const properties = await this.deps.debuggerManager.getObjectPropertiesById(objectId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            propertyCount: properties.length,
-                            properties,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: getErrorMessage(error, 'Failed to get object properties'),
-                            error: String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/debugger/handlers/session-management.d.ts

@@ -1,33 +0,0 @@
-import type { DebuggerManager } from '../../../domains/shared/modules.js';
-interface SessionManagementHandlersDeps {
-    debuggerManager: DebuggerManager;
-}
-export declare class SessionManagementHandlers {
-    private deps;
-    constructor(deps: SessionManagementHandlersDeps);
-    handleSaveSession(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleLoadSession(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleExportSession(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleListSessions(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

package/dist/src/server/domains/debugger/handlers/session-management.js

@@ -1,160 +0,0 @@
-import { argString, argObject } from '../../../domains/shared/parse-args.js';
-function getErrorMessage(error) {
-    if (typeof error === 'object' && error !== null && 'message' in error) {
-        const message = error.message;
-        if (typeof message === 'string' && message.length > 0) {
-            return message;
-        }
-    }
-    return String(error);
-}
-export class SessionManagementHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleSaveSession(args) {
-        const filePath = argString(args, 'filePath');
-        const metadata = argObject(args, 'metadata');
-        try {
-            const savedPath = await this.deps.debuggerManager.saveSession(filePath, metadata);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Session saved successfully',
-                            filePath: savedPath,
-                            breakpointCount: this.deps.debuggerManager.listBreakpoints().length,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to save session',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleLoadSession(args) {
-        const filePath = argString(args, 'filePath');
-        const sessionData = argString(args, 'sessionData');
-        try {
-            if (filePath) {
-                await this.deps.debuggerManager.loadSessionFromFile(filePath);
-            }
-            else if (sessionData) {
-                await this.deps.debuggerManager.importSession(sessionData);
-            }
-            else {
-                throw new Error('Either filePath or sessionData must be provided');
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Session loaded successfully',
-                            breakpointCount: this.deps.debuggerManager.listBreakpoints().length,
-                            pauseOnExceptions: this.deps.debuggerManager.getPauseOnExceptionsState(),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to load session',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleExportSession(args) {
-        const metadata = argObject(args, 'metadata');
-        try {
-            const session = this.deps.debuggerManager.exportSession(metadata);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Session exported successfully',
-                            session,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to export session',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleListSessions(_args) {
-        try {
-            const sessions = await this.deps.debuggerManager.listSavedSessions();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            count: sessions.length,
-                            sessions: sessions.map((s) => ({
-                                path: s.path,
-                                timestamp: s.timestamp,
-                                date: new Date(s.timestamp).toISOString(),
-                                metadata: s.metadata,
-                            })),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to list sessions',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/debugger/handlers/watch-expressions.d.ts

@@ -1,39 +0,0 @@
-import type { DebuggerManager } from '../../../domains/shared/modules.js';
-interface WatchExpressionsHandlersDeps {
-    debuggerManager: DebuggerManager;
-}
-export declare class WatchExpressionsHandlers {
-    private deps;
-    constructor(deps: WatchExpressionsHandlersDeps);
-    handleWatchAdd(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWatchRemove(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWatchList(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWatchEvaluateAll(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWatchClearAll(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};