@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,181 +0,0 @@
-import { argString } 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 WatchExpressionsHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleWatchAdd(args) {
-        try {
-            const expression = argString(args, 'expression', '');
-            const name = argString(args, 'name');
-            const watchManager = this.deps.debuggerManager.getWatchManager();
-            const watchId = watchManager.addWatch(expression, name);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Watch expression added',
-                            watchId,
-                            expression,
-                            name: name || expression,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to add watch expression',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleWatchRemove(args) {
-        try {
-            const watchId = argString(args, 'watchId', '');
-            const watchManager = this.deps.debuggerManager.getWatchManager();
-            const removed = watchManager.removeWatch(watchId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: removed,
-                            message: removed ? 'Watch expression removed' : 'Watch expression not found',
-                            watchId,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to remove watch expression',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleWatchList(_args) {
-        try {
-            const watchManager = this.deps.debuggerManager.getWatchManager();
-            const watches = watchManager.getAllWatches();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Found ${watches.length} watch expression(s)`,
-                            watches,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to list watch expressions',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleWatchEvaluateAll(args) {
-        try {
-            const callFrameId = argString(args, 'callFrameId');
-            const watchManager = this.deps.debuggerManager.getWatchManager();
-            const results = await watchManager.evaluateAll(callFrameId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Evaluated ${results.length} watch expression(s)`,
-                            results,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to evaluate watch expressions',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleWatchClearAll(_args) {
-        try {
-            const watchManager = this.deps.debuggerManager.getWatchManager();
-            watchManager.clearAll();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'All watch expressions cleared',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to clear watch expressions',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/debugger/handlers/xhr-breakpoint.d.ts

@@ -1,28 +0,0 @@
-import type { DebuggerManager } from '../../../domains/shared/modules.js';
-interface XHRBreakpointHandlersDeps {
-    debuggerManager: DebuggerManager;
-}
-export declare class XHRBreakpointHandlers {
-    private deps;
-    constructor(deps: XHRBreakpointHandlersDeps);
-    private ensureAdvancedFeaturesIfSupported;
-    handleXHRBreakpointSet(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleXHRBreakpointRemove(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleXHRBreakpointList(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

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

@@ -1,126 +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 XHRBreakpointHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async ensureAdvancedFeaturesIfSupported() {
-        if (hasEnsureAdvancedFeatures(this.deps.debuggerManager)) {
-            await this.deps.debuggerManager.ensureAdvancedFeatures();
-        }
-    }
-    async handleXHRBreakpointSet(args) {
-        try {
-            const urlPattern = argString(args, 'urlPattern', '');
-            await this.ensureAdvancedFeaturesIfSupported();
-            const xhrManager = this.deps.debuggerManager.getXHRManager();
-            const breakpointId = await xhrManager.setXHRBreakpoint(urlPattern);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'XHR breakpoint set',
-                            breakpointId,
-                            urlPattern,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to set XHR breakpoint',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleXHRBreakpointRemove(args) {
-        try {
-            const breakpointId = argString(args, 'breakpointId', '');
-            await this.ensureAdvancedFeaturesIfSupported();
-            const xhrManager = this.deps.debuggerManager.getXHRManager();
-            const removed = await xhrManager.removeXHRBreakpoint(breakpointId);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: removed,
-                            message: removed ? 'XHR breakpoint removed' : 'XHR breakpoint not found',
-                            breakpointId,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to remove XHR breakpoint',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleXHRBreakpointList(_args) {
-        try {
-            await this.ensureAdvancedFeaturesIfSupported();
-            const xhrManager = this.deps.debuggerManager.getXHRManager();
-            const breakpoints = xhrManager.getAllXHRBreakpoints();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: `Found ${breakpoints.length} XHR breakpoint(s)`,
-                            breakpoints,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            message: 'Failed to list XHR breakpoints',
-                            error: getErrorMessage(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

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

@@ -1,254 +0,0 @@
-import type { DebuggerManager } from '../../domains/shared/modules.js';
-import type { RuntimeInspector } from '../../domains/shared/modules.js';
-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 declare class DebuggerToolHandlers {
-    private debuggerManager;
-    private runtimeInspector;
-    private debuggerControl;
-    private debuggerStepping;
-    private debuggerEvaluate;
-    private debuggerState;
-    private sessionManagement;
-    private breakpointBasic;
-    private breakpointException;
-    private xhrBreakpoint;
-    private eventBreakpoint;
-    private watchExpressions;
-    private scopeInspection;
-    private blackbox;
-    constructor(debuggerManager: DebuggerManager, runtimeInspector: RuntimeInspector);
-    handleDebuggerEnable(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerDisable(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerPause(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerResume(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerStepInto(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerStepOver(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerStepOut(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerEvaluate(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerEvaluateGlobal(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerWaitForPaused(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleDebuggerGetPausedState(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleGetCallStack(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    handleBreakpointSet(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBreakpointRemove(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBreakpointList(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBreakpointSetOnException(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleXHRBreakpointSet(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleXHRBreakpointRemove(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleXHRBreakpointList(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleEventBreakpointSet(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleEventBreakpointSetCategory(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleEventBreakpointRemove(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleEventBreakpointList(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    handleGetScopeVariablesEnhanced(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleGetObjectProperties(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBlackboxAdd(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBlackboxAddCommon(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleBlackboxList(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export { DebuggerControlHandlers, DebuggerSteppingHandlers, DebuggerEvaluateHandlers, DebuggerStateHandlers, SessionManagementHandlers, BreakpointBasicHandlers, BreakpointExceptionHandlers, XHRBreakpointHandlers, EventBreakpointHandlers, WatchExpressionsHandlers, ScopeInspectionHandlers, BlackboxHandlers, };