@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,469 @@
+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

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