@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/modules/debugger/ScopeCoreExtended.test.js

@@ -1,469 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-vi.mock('@utils/logger', () => ({
-    logger: loggerState,
-}));
-import { PrerequisiteError } from '../../../src/errors/PrerequisiteError.js';
-import { getObjectPropertiesByIdCore, getObjectPropertiesCore, getScopeVariablesCore, } from '../../../src/modules/debugger/DebuggerManager.impl.core.scope.js';
-function makePausedCtx(overrides = {}) {
-    const send = vi.fn(async () => ({ result: [] }));
-    return {
-        enabled: true,
-        cdpSession: { send },
-        pausedState: {
-            callFrames: [
-                {
-                    callFrameId: 'cf-1',
-                    functionName: 'testFn',
-                    url: 'https://example.com/app.js',
-                    location: { lineNumber: 10, columnNumber: 2 },
-                    scopeChain: [
-                        { type: 'local', object: { objectId: 'obj-local' } },
-                    ],
-                },
-            ],
-        },
-        ...overrides,
-    };
-}
-describe('getScopeVariablesCore - prerequisite checks', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('throws PrerequisiteError when not enabled', async () => {
-        const ctx = { enabled: false, cdpSession: null, pausedState: null };
-        await expect(getScopeVariablesCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
-    });
-    it('throws PrerequisiteError when cdpSession is null', async () => {
-        const ctx = { enabled: true, cdpSession: null, pausedState: null };
-        await expect(getScopeVariablesCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
-    });
-    it('throws PrerequisiteError when not in paused state', async () => {
-        const ctx = { enabled: true, cdpSession: { send: vi.fn() }, pausedState: null };
-        await expect(getScopeVariablesCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
-        await expect(getScopeVariablesCore(ctx)).rejects.toThrow('Not in paused state');
-    });
-});
-describe('getScopeVariablesCore - call frame lookup', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('uses top frame when no callFrameId specified', async () => {
-        const ctx = makePausedCtx();
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.callFrameId).toBe('cf-1');
-        expect(result.callFrameInfo.functionName).toBe('testFn');
-    });
-    it('finds specific call frame by callFrameId', async () => {
-        const ctx = makePausedCtx({
-            pausedState: {
-                callFrames: [
-                    {
-                        callFrameId: 'cf-1',
-                        functionName: 'top',
-                        url: 'https://example.com/a.js',
-                        location: { lineNumber: 1, columnNumber: 0 },
-                        scopeChain: [],
-                    },
-                    {
-                        callFrameId: 'cf-2',
-                        functionName: 'bottom',
-                        url: 'https://example.com/b.js',
-                        location: { lineNumber: 20, columnNumber: 5 },
-                        scopeChain: [],
-                    },
-                ],
-            },
-        });
-        const result = await getScopeVariablesCore(ctx, { callFrameId: 'cf-2' });
-        expect(result.callFrameId).toBe('cf-2');
-        expect(result.callFrameInfo.functionName).toBe('bottom');
-    });
-    it('throws when specified callFrameId is not found', async () => {
-        const ctx = makePausedCtx();
-        await expect(getScopeVariablesCore(ctx, { callFrameId: 'cf-missing' })).rejects.toThrow('Call frame not found: cf-missing');
-    });
-    it('throws when there are no call frames at all', async () => {
-        const ctx = makePausedCtx({
-            pausedState: { callFrames: [] },
-        });
-        await expect(getScopeVariablesCore(ctx)).rejects.toThrow('Call frame not found: top frame');
-    });
-});
-describe('getScopeVariablesCore - __proto__ filtering', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('filters out __proto__ properties', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [
-                { name: '__proto__', value: { type: 'object', value: {} } },
-                { name: 'x', value: { type: 'number', value: 5 } },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.variables).toHaveLength(1);
-        expect(result.variables[0].name).toBe('x');
-    });
-});
-describe('getScopeVariablesCore - scope error handling', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('skips errored scopes when skipErrors is true (default)', async () => {
-        const ctx = makePausedCtx({
-            pausedState: {
-                callFrames: [
-                    {
-                        callFrameId: 'cf-1',
-                        functionName: 'fn',
-                        url: 'https://example.com/a.js',
-                        location: { lineNumber: 1, columnNumber: 0 },
-                        scopeChain: [
-                            { type: 'local', object: { objectId: 'obj-good' } },
-                            { type: 'closure', object: { objectId: 'obj-bad' } },
-                        ],
-                    },
-                ],
-            },
-        });
-        ctx.cdpSession.send
-            .mockResolvedValueOnce({
-            result: [{ name: 'a', value: { type: 'number', value: 1 } }],
-        })
-            .mockRejectedValueOnce(new Error('Scope error'));
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.success).toBe(true);
-        expect(result.successfulScopes).toBe(1);
-        expect(result.totalScopes).toBe(2);
-        expect(result.errors).toHaveLength(1);
-        expect(result.errors[0].scope).toBe('closure');
-        expect(result.errors[0].error).toBe('Scope error');
-    });
-    it('throws on scope error when skipErrors is false', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockRejectedValueOnce(new Error('Fatal scope error'));
-        await expect(getScopeVariablesCore(ctx, { skipErrors: false })).rejects.toThrow('Fatal scope error');
-    });
-    it('handles non-Error thrown from scope with toErrorMessage', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockRejectedValueOnce('string error');
-        const result = await getScopeVariablesCore(ctx, { skipErrors: true });
-        expect(result.errors).toHaveLength(1);
-        expect(result.errors[0].error).toBe('string error');
-    });
-    it('skips scopes without objectId silently', async () => {
-        const ctx = makePausedCtx({
-            pausedState: {
-                callFrames: [
-                    {
-                        callFrameId: 'cf-1',
-                        functionName: 'fn',
-                        url: 'https://example.com/a.js',
-                        location: { lineNumber: 1, columnNumber: 0 },
-                        scopeChain: [
-                            { type: 'local', object: {} },
-                            { type: 'global', object: { objectId: 'obj-g' } },
-                        ],
-                    },
-                ],
-            },
-        });
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [{ name: 'g', value: { type: 'string', value: 'hello' } }],
-        });
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.successfulScopes).toBe(1);
-        expect(result.variables).toHaveLength(1);
-        expect(result.variables[0].name).toBe('g');
-    });
-});
-describe('getScopeVariablesCore - nested object properties', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('resolves nested object properties when includeObjectProperties is true', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send
-            .mockResolvedValueOnce({
-            result: [
-                {
-                    name: 'user',
-                    value: { type: 'object', objectId: 'obj-user' },
-                    writable: true,
-                    configurable: true,
-                    enumerable: true,
-                },
-            ],
-        })
-            .mockResolvedValueOnce({
-            result: [
-                { name: 'name', value: { type: 'string', value: 'Alice' } },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx, {
-            includeObjectProperties: true,
-            maxDepth: 2,
-        });
-        expect(result.variables).toHaveLength(2);
-        expect(result.variables[1].name).toBe('user.name');
-        expect(result.variables[1].value).toBe('Alice');
-        expect(result.variables[1].scope).toBe('local');
-    });
-    it('does not resolve nested properties when includeObjectProperties is false', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [
-                {
-                    name: 'obj',
-                    value: { type: 'object', objectId: 'obj-nested' },
-                },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx, {
-            includeObjectProperties: false,
-        });
-        expect(result.variables).toHaveLength(1);
-        expect(ctx.cdpSession.send).toHaveBeenCalledTimes(1);
-    });
-    it('handles failure in nested property resolution gracefully', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send
-            .mockResolvedValueOnce({
-            result: [
-                {
-                    name: 'data',
-                    value: { type: 'object', objectId: 'obj-data' },
-                },
-            ],
-        })
-            .mockRejectedValueOnce(new Error('nested fail'));
-        const result = await getScopeVariablesCore(ctx, {
-            includeObjectProperties: true,
-            maxDepth: 2,
-        });
-        expect(result.variables).toHaveLength(1);
-        expect(result.variables[0].name).toBe('data');
-        expect(loggerState.debug).toHaveBeenCalledWith(expect.stringContaining('Failed to get object properties for obj-data'), expect.anything());
-    });
-    it('respects maxDepth=0 and does not resolve nested', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [
-                {
-                    name: 'deep',
-                    value: { type: 'object', objectId: 'obj-deep' },
-                },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx, {
-            includeObjectProperties: true,
-            maxDepth: 0,
-        });
-        expect(result.variables).toHaveLength(1);
-        expect(ctx.cdpSession.send).toHaveBeenCalledTimes(1);
-    });
-});
-describe('getScopeVariablesCore - callFrameInfo', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('uses (anonymous) for empty function name', async () => {
-        const ctx = makePausedCtx({
-            pausedState: {
-                callFrames: [
-                    {
-                        callFrameId: 'cf-1',
-                        functionName: '',
-                        url: 'https://example.com/app.js',
-                        location: { lineNumber: 5, columnNumber: 3 },
-                        scopeChain: [],
-                    },
-                ],
-            },
-        });
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.callFrameInfo.functionName).toBe('(anonymous)');
-        expect(result.callFrameInfo.location).toBe('https://example.com/app.js:5:3');
-    });
-});
-describe('getScopeVariablesCore - variable property mapping', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('maps writable, configurable, enumerable, and objectId fields', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [
-                {
-                    name: 'prop',
-                    value: { type: 'object', value: {}, objectId: 'obj-prop' },
-                    writable: false,
-                    configurable: true,
-                    enumerable: false,
-                },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx);
-        const v = result.variables[0];
-        expect(v.writable).toBe(false);
-        expect(v.configurable).toBe(true);
-        expect(v.enumerable).toBe(false);
-        expect(v.objectId).toBe('obj-prop');
-    });
-    it('sets type to unknown when prop.value.type is missing', async () => {
-        const ctx = makePausedCtx();
-        ctx.cdpSession.send.mockResolvedValueOnce({
-            result: [
-                { name: 'mystery', value: { value: 'hello' } },
-            ],
-        });
-        const result = await getScopeVariablesCore(ctx);
-        expect(result.variables[0].type).toBe('unknown');
-    });
-});
-describe('getObjectPropertiesByIdCore', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('throws when debugger not enabled', async () => {
-        const ctx = { enabled: false, cdpSession: null };
-        await expect(getObjectPropertiesByIdCore(ctx, 'obj-1')).rejects.toThrow('Debugger not enabled');
-    });
-    it('throws when objectId is empty string', async () => {
-        const ctx = { enabled: true, cdpSession: { send: vi.fn() } };
-        await expect(getObjectPropertiesByIdCore(ctx, '')).rejects.toThrow('objectId parameter is required');
-    });
-    it('throws when objectId is not a string', async () => {
-        const ctx = { enabled: true, cdpSession: { send: vi.fn() } };
-        await expect(getObjectPropertiesByIdCore(ctx, 123)).rejects.toThrow('objectId parameter is required');
-    });
-    it('retrieves and maps properties correctly', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: 'key', value: { type: 'string', value: 'val', description: 'val' } },
-                { name: 'count', value: { type: 'number', value: 42 } },
-                { name: 'noVal' },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesByIdCore(ctx, 'obj-1');
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({ name: 'key', value: 'val', type: 'string' });
-        expect(result[1]).toMatchObject({ name: 'count', value: 42, type: 'number' });
-    });
-    it('uses description as fallback value when value is undefined', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: 'fn', value: { type: 'function', description: 'function foo(){}', className: 'Function' } },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesByIdCore(ctx, 'obj-fn');
-        expect(result[0].value).toBe('function foo(){}');
-        expect(result[0].className).toBe('Function');
-    });
-    it('maps expired object handle error to stable message', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Could not find object with given id');
-        });
-        const ctx = { enabled: true, cdpSession: { send } };
-        await expect(getObjectPropertiesByIdCore(ctx, 'obj-x')).rejects.toThrow('Object handle is expired or invalid');
-    });
-    it('maps invalid remote object id error to stable message', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Invalid remote object id');
-        });
-        const ctx = { enabled: true, cdpSession: { send } };
-        await expect(getObjectPropertiesByIdCore(ctx, 'obj-y')).rejects.toThrow('Object handle is expired or invalid');
-    });
-    it('re-throws other errors without wrapping', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Random CDP error');
-        });
-        const ctx = { enabled: true, cdpSession: { send } };
-        await expect(getObjectPropertiesByIdCore(ctx, 'obj-z')).rejects.toThrow('Random CDP error');
-    });
-    it('sets type to unknown when prop.value.type is missing', async () => {
-        const send = vi.fn(async () => ({
-            result: [{ name: 'x', value: { value: 'hello' } }],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesByIdCore(ctx, 'obj-1');
-        expect(result[0].type).toBe('unknown');
-    });
-});
-describe('getObjectPropertiesCore', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('returns empty array when maxDepth is 0', async () => {
-        const ctx = { enabled: true, cdpSession: { send: vi.fn() } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 0);
-        expect(result).toEqual([]);
-        expect(ctx.cdpSession.send).not.toHaveBeenCalled();
-    });
-    it('returns empty array when cdpSession is null', async () => {
-        const ctx = { enabled: true, cdpSession: null };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result).toEqual([]);
-    });
-    it('filters __proto__ from results', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: '__proto__', value: { type: 'object' } },
-                { name: 'valid', value: { type: 'number', value: 10 } },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result).toHaveLength(1);
-        expect(result[0].name).toBe('valid');
-    });
-    it('assigns local scope type to all returned variables', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: 'a', value: { type: 'string', value: 'hello' } },
-                { name: 'b', value: { type: 'number', value: 42 } },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result.every((v) => v.scope === 'local')).toBe(true);
-    });
-    it('returns empty array on CDP error', async () => {
-        const send = vi.fn(async () => {
-            throw new Error('Connection lost');
-        });
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result).toEqual([]);
-        expect(loggerState.debug).toHaveBeenCalledWith(expect.stringContaining('Failed to get object properties'), expect.anything());
-    });
-    it('includes objectId in returned variables', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: 'nested', value: { type: 'object', objectId: 'obj-nested', value: {} } },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result[0].objectId).toBe('obj-nested');
-    });
-    it('sets type to unknown when value.type is missing', async () => {
-        const send = vi.fn(async () => ({
-            result: [
-                { name: 'untyped', value: { value: 'data' } },
-            ],
-        }));
-        const ctx = { enabled: true, cdpSession: { send } };
-        const result = await getObjectPropertiesCore(ctx, 'obj-1', 1);
-        expect(result[0].type).toBe('unknown');
-    });
-});

package/dist/tests/modules/debugger/ScriptManager.impl.class.test.d.ts

@@ -1 +0,0 @@
-export {};