@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/tests/modules/security/ExecutionSandbox.test.js

@@ -1,122 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const sandboxState = vi.hoisted(() => {
-    class WorkerMock {
-        script;
-        options;
-        listeners = new Map();
-        terminate = vi.fn(async () => 0);
-        constructor(script, options) {
-            this.script = script;
-            this.options = options;
-        }
-        on(event, callback) {
-            const callbacks = this.listeners.get(event) ?? [];
-            callbacks.push(callback);
-            this.listeners.set(event, callbacks);
-            return this;
-        }
-        emit(event, payload) {
-            const callbacks = this.listeners.get(event) ?? [];
-            callbacks.forEach((callback) => callback(payload));
-        }
-    }
-    return {
-        instances: [],
-        WorkerMock,
-    };
-});
-vi.mock('node:worker_threads', () => ({
-    Worker: class WorkerCtor {
-        inner;
-        terminate;
-        constructor(script, options) {
-            this.inner = new sandboxState.WorkerMock(script, options);
-            sandboxState.instances.push(this.inner);
-            this.terminate = this.inner.terminate;
-        }
-        on(event, callback) {
-            this.inner.on(event, callback);
-            return this;
-        }
-    },
-}));
-vi.mock('@src/utils/concurrency', () => ({
-    cpuLimit: vi.fn(async (fn) => fn()),
-}));
-import { cpuLimit } from '../../../src/utils/concurrency.js';
-import { ExecutionSandbox } from '../../../src/modules/security/ExecutionSandbox.js';
-describe('ExecutionSandbox', () => {
-    beforeEach(() => {
-        sandboxState.instances.length = 0;
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-    });
-    it('executes code and returns worker output', async () => {
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: '1 + 2', timeoutMs: 500 });
-        const worker = sandboxState.instances[0];
-        worker.emit('message', { ok: true, output: 3, timedOut: false });
-        await expect(task).resolves.toMatchObject({ ok: true, output: 3, timedOut: false });
-        expect(cpuLimit).toHaveBeenCalledOnce();
-        expect(worker.terminate).toHaveBeenCalledOnce();
-    });
-    it('passes default timeout and memory limits to worker', async () => {
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: '42' });
-        const worker = sandboxState.instances[0];
-        const options = worker.options;
-        expect(options.workerData.timeoutMs).toBe(5000);
-        expect(options.resourceLimits.maxOldGenerationSizeMb).toBe(128);
-        expect(options.resourceLimits.maxYoungGenerationSizeMb).toBe(32);
-        worker.emit('message', { ok: true, output: 42 });
-        await expect(task).resolves.toMatchObject({ ok: true, output: 42 });
-    });
-    it('returns worker error events as failed result', async () => {
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: 'throw new Error("x")' });
-        const worker = sandboxState.instances[0];
-        worker.emit('error', new Error('kaboom'));
-        await expect(task).resolves.toMatchObject({
-            ok: false,
-            timedOut: false,
-            error: expect.stringContaining('kaboom'),
-        });
-    });
-    it('enforces hard timeout and terminates stalled worker', async () => {
-        vi.useFakeTimers();
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: 'while(true){}', timeoutMs: 10 });
-        const worker = sandboxState.instances[0];
-        vi.advanceTimersByTime(2011);
-        await expect(task).resolves.toMatchObject({
-            ok: false,
-            timedOut: true,
-            error: expect.stringContaining('timed out'),
-        });
-        expect(worker.terminate).toHaveBeenCalled();
-    });
-    it('returns unexpected exit when worker exits before response', async () => {
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: 'process.exit(1)' });
-        const worker = sandboxState.instances[0];
-        worker.emit('exit', 1);
-        await expect(task).resolves.toMatchObject({
-            ok: false,
-            timedOut: false,
-            error: expect.stringContaining('code 1'),
-        });
-    });
-    it('embeds restricted globals and vm isolation in worker script', async () => {
-        const sandbox = new ExecutionSandbox();
-        const task = sandbox.execute({ code: '2 + 2' });
-        const worker = sandboxState.instances[0];
-        expect(worker.script).toContain('vm.createContext');
-        expect(worker.script).toContain('Explicitly denied');
-        expect(worker.script).toContain('require');
-        expect(worker.script).toContain('codeGeneration');
-        worker.emit('message', { ok: true, output: 4 });
-        await expect(task).resolves.toMatchObject({ ok: true, output: 4 });
-    });
-});

package/dist/tests/modules/security/RedactionService.test.d.ts

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

package/dist/tests/modules/security/RedactionService.test.js

@@ -1,56 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { RedactionService } from '../../../src/modules/security/RedactionService.js';
-describe('RedactionService', () => {
-    const envBackup = process.env.jshook_REDACTION_LEVEL;
-    afterEach(() => {
-        process.env.jshook_REDACTION_LEVEL = envBackup;
-    });
-    it('redacts bearer/jwt/api keys in standard mode', () => {
-        const service = new RedactionService('standard');
-        const input = 'Authorization: Bearer abcdefghijklmnopqrstuvwxyz ' +
-            'jwt eyJ1234567890abc.DEF1234567890ghi.JKL1234567890mno ' +
-            'sk-123456789012345678901234567890';
-        const out = service.redactString(input);
-        expect(out).toContain('Bearer [REDACTED]');
-        expect(out).toContain('[REDACTED_JWT]');
-        expect(out).toContain('[REDACTED_API_KEY]');
-    });
-    it('strict mode additionally redacts emails and filesystem paths', () => {
-        const service = new RedactionService('strict');
-        const input = 'mail me at user@example.com path C:\\Users\\alice\\secret.txt /home/bob/key.pem';
-        const out = service.redactString(input);
-        expect(out).toContain('[REDACTED_EMAIL]');
-        expect(out).toContain('[REDACTED_PATH]');
-    });
-    it('none mode leaves content and object references unchanged', () => {
-        const service = new RedactionService('none');
-        const obj = { token: 'Bearer secret', nested: { email: 'a@b.com' } };
-        expect(service.redactString('Bearer abc')).toBe('Bearer abc');
-        expect(service.redactObject(obj)).toBe(obj);
-    });
-    it('redactObject returns original object when serialization fails', () => {
-        const service = new RedactionService('standard');
-        const circular = { token: 'Bearer abc' };
-        circular.self = circular;
-        const result = service.redactObject(circular);
-        expect(result).toBe(circular);
-    });
-    it('setLevel updates active pattern stats', () => {
-        const service = new RedactionService('standard');
-        const standardStats = service.getStats();
-        service.setLevel('strict');
-        const strictStats = service.getStats();
-        expect(service.getLevel()).toBe('strict');
-        expect(strictStats.activePatterns).toBeGreaterThan(standardStats.activePatterns);
-        expect(strictStats.patternNames).toContain('email');
-    });
-});

package/dist/tests/modules/stealth/StealthScripts.test.d.ts

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

package/dist/tests/modules/stealth/StealthScripts.test.js

@@ -1,67 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { StealthScripts } from '../../../src/modules/stealth/StealthScripts.js';
-function createPageMock() {
-    return {
-        evaluateOnNewDocument: vi.fn(async () => undefined),
-        setUserAgent: vi.fn(async () => undefined),
-    };
-}
-describe('StealthScripts', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('injectAll invokes all stealth patch methods', async () => {
-        const page = createPageMock();
-        const spies = [
-            vi.spyOn(StealthScripts, 'hideWebDriver').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockChrome').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockPlugins').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'fixPermissions').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockCanvas').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockWebGL').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'fixLanguages').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockBattery').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'fixMediaDevices').mockResolvedValue(undefined),
-            vi.spyOn(StealthScripts, 'mockNotifications').mockResolvedValue(undefined),
-        ];
-        await StealthScripts.injectAll(page);
-        spies.forEach((spy) => expect(spy).toHaveBeenCalledOnce());
-    });
-    it('hideWebDriver injects a preload script', async () => {
-        const page = createPageMock();
-        await StealthScripts.hideWebDriver(page);
-        expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
-        const [script] = page.evaluateOnNewDocument.mock.calls[0];
-        expect(typeof script).toBe('function');
-    });
-    it('setRealisticUserAgent uses platform-specific UA and navigator overrides', async () => {
-        const page = createPageMock();
-        await StealthScripts.setRealisticUserAgent(page, 'mac');
-        expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Macintosh'));
-        const [script, platformValue] = page.evaluateOnNewDocument.mock.calls[0];
-        expect(typeof script).toBe('function');
-        expect(platformValue).toBe('MacIntel');
-    });
-    it('setRealisticUserAgent defaults to windows platform', async () => {
-        const page = createPageMock();
-        await StealthScripts.setRealisticUserAgent(page);
-        expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Windows NT 10.0'));
-        expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'Win32');
-    });
-    it('exposes hardened browser launch arguments', () => {
-        const args = StealthScripts.getRecommendedLaunchArgs();
-        expect(args).toContain('--disable-blink-features=AutomationControlled');
-        expect(args).toContain('--no-sandbox');
-        expect(args).toContain('--window-size=1920,1080');
-        expect(new Set(args).size).toBe(args.length);
-    });
-    it('fixPermissions and fixMediaDevices both inject scripts', async () => {
-        const page = createPageMock();
-        await StealthScripts.fixPermissions(page);
-        await StealthScripts.fixMediaDevices(page);
-        expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/tests/modules/symbolic/JSVMPSymbolicExecutor.test.d.ts

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

package/dist/tests/modules/symbolic/JSVMPSymbolicExecutor.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { JSVMPOpcode, JSVMPSymbolicExecutor, } from '../../../src/modules/symbolic/JSVMPSymbolicExecutor.js';
-describe('JSVMPSymbolicExecutor', () => {
-    it('executes arithmetic stack instructions', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.PUSH, operands: [2], location: 0 },
-            { opcode: JSVMPOpcode.PUSH, operands: [3], location: 1 },
-            { opcode: JSVMPOpcode.ADD, operands: [], location: 2 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 3 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.executionTrace.length).toBeGreaterThan(0);
-        expect(result.finalState.stack.length).toBe(1);
-        expect(result.confidence).toBeGreaterThan(0);
-    });
-    it('adds path constraint for JZ instruction', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.PUSH, operands: [0], location: 0 },
-            { opcode: JSVMPOpcode.JZ, operands: [3], location: 1 },
-            { opcode: JSVMPOpcode.PUSH, operands: [1], location: 2 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 3 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.finalState.pathConstraints.some((c) => c.type === 'equality')).toBe(true);
-        expect(result.finalState.pc).toBe(4);
-    });
-    it('handles unknown opcode by advancing pc', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: 0xab, operands: [], location: 0 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 1 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.executionTrace[0]?.pc).toBe(0);
-        expect(result.finalState.pc).toBe(2);
-    });
-    it('stops when maxSteps is reached', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 0 },
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 1 },
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 2 },
-        ];
-        const result = await executor.executeJSVMP({ instructions, maxSteps: 1 });
-        expect(result.executionTrace.length).toBe(1);
-    });
-    it('records warning when timeout is exceeded', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = Array.from({ length: 20 }, (_, i) => ({
-            opcode: JSVMPOpcode.NOP,
-            operands: [],
-            location: i,
-        }));
-        const result = await executor.executeJSVMP({ instructions, timeout: -1 });
-        expect(result.warnings.length).toBeGreaterThan(0);
-    });
-});

package/dist/tests/modules/symbolic/SymbolicExecutor.test.d.ts

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

package/dist/tests/modules/symbolic/SymbolicExecutor.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SymbolicExecutor } from '../../../src/modules/symbolic/SymbolicExecutor.js';
-describe('SymbolicExecutor', () => {
-    it('creates symbolic values with unique ids', () => {
-        const executor = new SymbolicExecutor();
-        const a = executor.createSymbolicValue('number', 'a');
-        const b = executor.createSymbolicValue('number', 'b');
-        expect(a.id).not.toBe(b.id);
-        expect(a.name).toBe('a');
-    });
-    it('executes simple code and returns result shape', async () => {
-        const executor = new SymbolicExecutor();
-        const result = await executor.execute({
-            code: 'let x = 1; if (x) { x = 2; }',
-            maxPaths: 5,
-            maxDepth: 5,
-        });
-        expect(result).toHaveProperty('paths');
-        expect(result).toHaveProperty('coverage');
-        expect(result.stats.totalPaths).toBeGreaterThanOrEqual(0);
-    });
-    it('stops with timeout warning when timeout is too small', async () => {
-        const executor = new SymbolicExecutor();
-        const result = await executor.execute({
-            code: 'let x=0; while(x<10){ x=x+1; }',
-            timeout: 0,
-            maxPaths: 10,
-        });
-        expect(result.warnings.length).toBeGreaterThan(0);
-    });
-    it('marks contradictory constraints unsatisfiable in solver', () => {
-        const executor = new SymbolicExecutor();
-        const constraints = [
-            { type: 'range', expression: 'x > 10', description: '' },
-            { type: 'inequality', expression: 'x < 5', description: '' },
-        ];
-        const solved = executor.simpleSMTSolver(constraints);
-        expect(solved.satisfiable).toBe(false);
-    });
-    it('detects contradictory expressions via helper', () => {
-        const executor = new SymbolicExecutor();
-        expect(executor.areContradictory('x > 10', 'x < 10')).toBe(true);
-        expect(executor.areContradictory('x > 1', 'x < 99')).toBe(false);
-    });
-});

package/dist/tests/packages/extension-sdk/ExtensionBuilder.test.d.ts

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

package/dist/tests/packages/extension-sdk/ExtensionBuilder.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ExtensionBuilder, createExtension } from '../../../packages/extension-sdk/src/plugin.js';
-describe('ExtensionBuilder', () => {
-    describe('constructor and basic properties', () => {
-        it('creates builder with id and version', () => {
-            const builder = new ExtensionBuilder('my-plugin', '1.0.0');
-            expect(builder._id).toBe('my-plugin');
-            expect(builder._version).toBe('1.0.0');
-        });
-        it('createExtension factory creates builder', () => {
-            const builder = createExtension('factory-plugin', '2.0.0');
-            expect(builder._id).toBe('factory-plugin');
-            expect(builder._version).toBe('2.0.0');
-        });
-        it('has default values for optional properties', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            expect(builder._name).toBe('');
-            expect(builder._description).toBe('');
-            expect(builder._compatibleCore).toBe('>=0.1.0');
-            expect(builder._tools).toEqual([]);
-            expect(builder._allowCommands).toEqual([]);
-            expect(builder._allowHosts).toEqual([]);
-            expect(builder._allowTools).toEqual([]);
-            expect(builder._metrics).toEqual([]);
-            expect(builder._configDefaults).toEqual({});
-            expect(builder._onLoadHandler).toBeUndefined();
-            expect(builder._onValidateHandler).toBeUndefined();
-            expect(builder._onActivateHandler).toBeUndefined();
-            expect(builder._onDeactivateHandler).toBeUndefined();
-        });
-    });
-    describe('name / description / compatibleCore', () => {
-        it('name sets name and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.name('My Plugin');
-            expect(result).toBe(builder);
-            expect(builder._name).toBe('My Plugin');
-        });
-        it('description sets description and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.description('A test plugin');
-            expect(result).toBe(builder);
-            expect(builder._description).toBe('A test plugin');
-        });
-        it('compatibleCore sets version range and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.compatibleCore('^1.0.0');
-            expect(result).toBe(builder);
-            expect(builder._compatibleCore).toBe('^1.0.0');
-        });
-    });
-    describe('allowCommand / allowHost / allowTool / metric', () => {
-        it('allowCommand adds single command and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.allowCommand('echo');
-            expect(result).toBe(builder);
-            expect(builder._allowCommands).toEqual(['echo']);
-        });
-        it('allowCommand adds multiple commands', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.allowCommand(['echo', 'ping']);
-            expect(builder._allowCommands).toEqual(['echo', 'ping']);
-        });
-        it('allowHost adds single host and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.allowHost('example.com');
-            expect(result).toBe(builder);
-            expect(builder._allowHosts).toEqual(['example.com']);
-        });
-        it('allowHost adds multiple hosts', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.allowHost(['api.example.com', 'cdn.example.com']);
-            expect(builder._allowHosts).toEqual(['api.example.com', 'cdn.example.com']);
-        });
-        it('allowTool adds single tool and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.allowTool('page_navigate');
-            expect(result).toBe(builder);
-            expect(builder._allowTools).toEqual(['page_navigate']);
-        });
-        it('allowTool adds multiple tools', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.allowTool(['page_navigate', 'page_screenshot']);
-            expect(builder._allowTools).toEqual(['page_navigate', 'page_screenshot']);
-        });
-        it('metric adds single metric and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.metric('plugin.loaded');
-            expect(result).toBe(builder);
-            expect(builder._metrics).toEqual(['plugin.loaded']);
-        });
-        it('metric adds multiple metrics', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.metric(['plugin.loaded', 'plugin.activated']);
-            expect(builder._metrics).toEqual(['plugin.loaded', 'plugin.activated']);
-        });
-    });
-    describe('configDefault', () => {
-        it('sets config default and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const result = builder.configDefault('timeout', 5000);
-            expect(result).toBe(builder);
-            expect(builder._configDefaults).toEqual({ timeout: 5000 });
-        });
-        it('allows multiple config defaults', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.configDefault('timeout', 5000);
-            builder.configDefault('retries', 3);
-            expect(builder._configDefaults).toEqual({ timeout: 5000, retries: 3 });
-        });
-    });
-    describe('tool', () => {
-        it('adds tool definition and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const handler = async () => ({ content: [{ type: 'text', text: 'ok' }] });
-            const result = builder.tool('echo', 'Echoes input', { message: { type: 'string' } }, handler);
-            expect(result).toBe(builder);
-            expect(builder._tools).toHaveLength(1);
-            expect(builder._tools[0].name).toBe('echo');
-            expect(builder._tools[0].description).toBe('Echoes input');
-            expect(builder._tools[0].schema).toEqual({
-                type: 'object',
-                properties: { message: { type: 'string' } },
-            });
-            expect(builder._tools[0].handler).toBe(handler);
-        });
-    });
-    describe('lifecycle handlers', () => {
-        it('onLoad sets handler and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const handler = () => { };
-            const result = builder.onLoad(handler);
-            expect(result).toBe(builder);
-            expect(builder._onLoadHandler).toBe(handler);
-        });
-        it('onValidate sets handler and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const handler = () => ({ valid: true, errors: [] });
-            const result = builder.onValidate(handler);
-            expect(result).toBe(builder);
-            expect(builder._onValidateHandler).toBe(handler);
-        });
-        it('onActivate sets handler and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const handler = async () => { };
-            const result = builder.onActivate(handler);
-            expect(result).toBe(builder);
-            expect(builder._onActivateHandler).toBe(handler);
-        });
-        it('onDeactivate sets handler and returns this', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const handler = async () => { };
-            const result = builder.onDeactivate(handler);
-            expect(result).toBe(builder);
-            expect(builder._onDeactivateHandler).toBe(handler);
-        });
-    });
-    describe('fluent chaining', () => {
-        it('supports method chaining', () => {
-            const builder = createExtension('chain-test', '1.0.0')
-                .name('Chain Test')
-                .description('Testing method chaining')
-                .compatibleCore('^1.0.0')
-                .allowTool('page_navigate')
-                .metric('test.metric')
-                .configDefault('timeout', 5000)
-                .onLoad(() => { })
-                .onActivate(async () => { });
-            expect(builder._id).toBe('chain-test');
-            expect(builder._name).toBe('Chain Test');
-            expect(builder._description).toBe('Testing method chaining');
-            expect(builder._compatibleCore).toBe('^1.0.0');
-            expect(builder._allowTools).toEqual(['page_navigate']);
-            expect(builder._metrics).toEqual(['test.metric']);
-            expect(builder._configDefaults).toEqual({ timeout: 5000 });
-            expect(builder._onLoadHandler).toBeDefined();
-            expect(builder._onActivateHandler).toBeDefined();
-        });
-    });
-    describe('property access', () => {
-        it('properties are accessible', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            builder.name('Test');
-            expect(builder._name).toBe('Test');
-            const tools = builder._tools;
-            expect(Array.isArray(tools)).toBe(true);
-        });
-        it('handler properties return the assigned functions', () => {
-            const builder = new ExtensionBuilder('test', '1.0.0');
-            const loadHandler = () => { };
-            const validateHandler = () => ({ valid: true, errors: [] });
-            const activateHandler = async () => { };
-            const deactivateHandler = async () => { };
-            builder
-                .onLoad(loadHandler)
-                .onValidate(validateHandler)
-                .onActivate(activateHandler)
-                .onDeactivate(deactivateHandler);
-            expect(builder._onLoadHandler).toBe(loadHandler);
-            expect(builder._onValidateHandler).toBe(validateHandler);
-            expect(builder._onActivateHandler).toBe(activateHandler);
-            expect(builder._onDeactivateHandler).toBe(deactivateHandler);
-        });
-    });
-});

package/dist/tests/server/ExtensionManagementHandlers.test.d.ts

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