@jshookmcp/jshook 0.1.8 → 0.1.9

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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