@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/tests/server/domains/transform/transform-base.test.js

@@ -0,0 +1,176 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TransformToolHandlersBase } from '../../../../src/server/domains/transform/handlers.impl.transform-base.js';
+vi.mock('@utils/WorkerPool', () => ({
+    WorkerPool: class MockWorkerPool {
+        submit = vi.fn();
+        close = vi.fn().mockResolvedValue(undefined);
+    },
+}));
+vi.mock('@src/constants', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        TRANSFORM_WORKER_TIMEOUT_MS: 5000,
+        TRANSFORM_CRYPTO_POOL_MAX_WORKERS: 2,
+        TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: 30000,
+        TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: 64,
+        TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: 32,
+    };
+});
+class TestableBase extends TransformToolHandlersBase {
+    constructor() {
+        super(null);
+    }
+    testParseTransforms(raw) {
+        return this.parseTransforms(raw);
+    }
+    testParseBoolean(raw, def) {
+        return this.parseBoolean(raw, def);
+    }
+    testRequireString(raw, field) {
+        return this.requireString(raw, field);
+    }
+    testEscapeStringContent(v, q) {
+        return this.escapeStringContent(v, q);
+    }
+    testDecodeEscapedString(v) {
+        return this.decodeEscapedString(v);
+    }
+    testIsValidIdentifier(v) {
+        return this.isValidIdentifier(v);
+    }
+    testParseTestInputs(raw) {
+        return this.parseTestInputs(raw);
+    }
+}
+describe('TransformToolHandlersBase', () => {
+    let base;
+    beforeEach(() => {
+        base = new TestableBase();
+    });
+    describe('parseTransforms', () => {
+        it('accepts array input, validates, and dedupes', () => {
+            expect(base.testParseTransforms(['constant_fold', 'constant_fold', 'rename_vars'])).toEqual([
+                'constant_fold',
+                'rename_vars',
+            ]);
+        });
+        it('accepts comma-separated strings, validates, and dedupes', () => {
+            expect(base.testParseTransforms('constant_fold, dead_code_remove, constant_fold')).toEqual([
+                'constant_fold',
+                'dead_code_remove',
+            ]);
+        });
+        it('throws on empty input', () => {
+            expect(() => base.testParseTransforms([])).toThrow('transforms must contain at least one transform');
+            expect(() => base.testParseTransforms('')).toThrow('transforms must contain at least one transform');
+            expect(() => base.testParseTransforms(undefined)).toThrow('transforms must contain at least one transform');
+        });
+        it('throws on invalid transform kind', () => {
+            expect(() => base.testParseTransforms(['nope'])).toThrow('Unsupported transform: nope');
+        });
+    });
+    describe('parseBoolean', () => {
+        it('returns booleans as-is', () => {
+            expect(base.testParseBoolean(true, false)).toBe(true);
+            expect(base.testParseBoolean(false, true)).toBe(false);
+        });
+        it('parses truthy strings', () => {
+            for (const v of ['true', '1', 'yes', 'on', ' TRUE ', 'On']) {
+                expect(base.testParseBoolean(v, false)).toBe(true);
+            }
+        });
+        it('parses falsy strings', () => {
+            for (const v of ['false', '0', 'no', 'off', ' FALSE ', 'Off']) {
+                expect(base.testParseBoolean(v, true)).toBe(false);
+            }
+        });
+        it('parses 1/0 numbers', () => {
+            expect(base.testParseBoolean(1, false)).toBe(true);
+            expect(base.testParseBoolean(0, true)).toBe(false);
+        });
+        it('falls back to default for other values', () => {
+            expect(base.testParseBoolean(2, true)).toBe(true);
+            expect(base.testParseBoolean('maybe', false)).toBe(false);
+            expect(base.testParseBoolean(null, true)).toBe(true);
+            expect(base.testParseBoolean(undefined, false)).toBe(false);
+        });
+    });
+    describe('requireString', () => {
+        it('returns valid non-empty strings', () => {
+            expect(base.testRequireString('ok', 'field')).toBe('ok');
+            expect(base.testRequireString(' ', 'field')).toBe(' ');
+        });
+        it('throws on empty string', () => {
+            expect(() => base.testRequireString('', 'code')).toThrow('code must be a non-empty string');
+        });
+        it('throws on non-string', () => {
+            expect(() => base.testRequireString(123, 'code')).toThrow('code must be a non-empty string');
+        });
+    });
+    describe('escapeStringContent', () => {
+        it('doubles backslashes and escapes control characters', () => {
+            expect(base.testEscapeStringContent('a\\b', "'")).toBe('a\\\\b');
+            expect(base.testEscapeStringContent('a\nb', "'")).toBe('a\\nb');
+            expect(base.testEscapeStringContent('a\tb', "'")).toBe('a\\tb');
+            expect(base.testEscapeStringContent('a\rb', "'")).toBe('a\\rb');
+        });
+        it('escapes double quotes when quote is "', () => {
+            expect(base.testEscapeStringContent('a"b', '"')).toBe('a\\"b');
+            expect(base.testEscapeStringContent("a'b", '"')).toBe("a'b");
+        });
+        it("escapes single quotes when quote is '", () => {
+            expect(base.testEscapeStringContent("a'b", "'")).toBe("a\\'b");
+            expect(base.testEscapeStringContent('a"b', "'")).toBe('a"b');
+        });
+    });
+    describe('decodeEscapedString', () => {
+        it('decodes \\xHH sequences', () => {
+            expect(base.testDecodeEscapedString('\\x48\\x65\\x6c\\x6c\\x6f')).toBe('Hello');
+        });
+        it('decodes \\uHHHH sequences', () => {
+            expect(base.testDecodeEscapedString('\\u0048\\u0065')).toBe('He');
+        });
+        it('decodes \\u{HHHH} sequences', () => {
+            expect(base.testDecodeEscapedString('\\u{1F600}')).toBe('\u{1F600}');
+        });
+        it('decodes control sequences', () => {
+            expect(base.testDecodeEscapedString('\\n')).toBe('\n');
+            expect(base.testDecodeEscapedString('\\r')).toBe('\r');
+            expect(base.testDecodeEscapedString('\\t')).toBe('\t');
+            expect(base.testDecodeEscapedString('\\v')).toBe('\v');
+            expect(base.testDecodeEscapedString('\\f')).toBe('\f');
+            expect(base.testDecodeEscapedString('\\0')).toBe('\0');
+        });
+        it('decodes escaped quotes and backslashes', () => {
+            expect(base.testDecodeEscapedString('\\"')).toBe('"');
+            expect(base.testDecodeEscapedString("\\\'")).toBe("'");
+            expect(base.testDecodeEscapedString('\\\\')).toBe('\\');
+        });
+    });
+    describe('isValidIdentifier', () => {
+        it('accepts valid identifier syntax', () => {
+            expect(base.testIsValidIdentifier('foo')).toBe(true);
+            expect(base.testIsValidIdentifier('_bar')).toBe(true);
+            expect(base.testIsValidIdentifier('$baz')).toBe(true);
+            expect(base.testIsValidIdentifier('a1')).toBe(true);
+            expect(base.testIsValidIdentifier('class')).toBe(true);
+        });
+        it('rejects invalid identifier syntax', () => {
+            expect(base.testIsValidIdentifier('')).toBe(false);
+            expect(base.testIsValidIdentifier('1foo')).toBe(false);
+            expect(base.testIsValidIdentifier('foo-bar')).toBe(false);
+        });
+    });
+    describe('parseTestInputs', () => {
+        it('stringifies values and returns string array', () => {
+            expect(base.testParseTestInputs([1, 'a', true])).toEqual(['1', 'a', 'true']);
+        });
+        it('throws on empty arrays', () => {
+            expect(() => base.testParseTestInputs([])).toThrow('testInputs cannot be empty');
+        });
+        it('throws when input is not an array', () => {
+            expect(() => base.testParseTestInputs('nope')).toThrow('testInputs must be an array of strings');
+        });
+    });
+});

package/dist/tests/server/domains/transform/transform-ops.test.d.ts

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

package/dist/tests/server/domains/transform/transform-ops.test.js

@@ -0,0 +1,242 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TransformToolHandlersOps } from '../../../../src/server/domains/transform/handlers.impl.transform-ops.js';
+vi.mock('@utils/WorkerPool', () => ({
+    WorkerPool: class MockWorkerPool {
+        submit = vi.fn();
+        close = vi.fn().mockResolvedValue(undefined);
+    },
+}));
+vi.mock('@src/constants', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        TRANSFORM_WORKER_TIMEOUT_MS: 5000,
+        TRANSFORM_CRYPTO_POOL_MAX_WORKERS: 2,
+        TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: 30000,
+        TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: 64,
+        TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: 32,
+    };
+});
+class TestableOps extends TransformToolHandlersOps {
+    constructor() {
+        super(null);
+    }
+    testTransformConstantFold(code) {
+        return this.transformConstantFold(code);
+    }
+    testTransformStringDecrypt(code) {
+        return this.transformStringDecrypt(code);
+    }
+    testTransformDeadCodeRemove(code) {
+        return this.transformDeadCodeRemove(code);
+    }
+    testTransformControlFlowFlatten(code) {
+        return this.transformControlFlowFlatten(code);
+    }
+    testTransformRenameVars(code) {
+        return this.transformRenameVars(code);
+    }
+    testApplySingleTransform(code, kind) {
+        return this.applySingleTransform(code, kind);
+    }
+    testApplyTransforms(code, kinds) {
+        return this.applyTransforms(code, kinds);
+    }
+    testBuildDiff(a, b) {
+        return this.buildDiff(a, b);
+    }
+    testBuildFallbackDiff(a, b) {
+        return this.buildFallbackDiff(a, b);
+    }
+    testParseTransforms(raw) {
+        return this.parseTransforms(raw);
+    }
+    testParseBoolean(raw, def) {
+        return this.parseBoolean(raw, def);
+    }
+    testRequireString(raw, field) {
+        return this.requireString(raw, field);
+    }
+    testEscapeStringContent(v, q) {
+        return this.escapeStringContent(v, q);
+    }
+    testDecodeEscapedString(v) {
+        return this.decodeEscapedString(v);
+    }
+    testIsValidIdentifier(v) {
+        return this.isValidIdentifier(v);
+    }
+    testParseTestInputs(raw) {
+        return this.parseTestInputs(raw);
+    }
+    getChains() {
+        return this.chains;
+    }
+    testResolveTransformsForApply(chainName, raw) {
+        return this.resolveTransformsForApply(chainName, raw);
+    }
+}
+describe('TransformToolHandlersOps', () => {
+    let ops;
+    beforeEach(() => {
+        ops = new TestableOps();
+    });
+    describe('transformConstantFold', () => {
+        it('folds numeric binary expressions', () => {
+            expect(ops.testTransformConstantFold('1+2')).toBe('3');
+            expect(ops.testTransformConstantFold('10-3')).toBe('7');
+            expect(ops.testTransformConstantFold('4*5')).toBe('20');
+            expect(ops.testTransformConstantFold('10/2')).toBe('5');
+            expect(ops.testTransformConstantFold('10%3')).toBe('1');
+        });
+        it('leaves division/modulo by zero unchanged', () => {
+            expect(ops.testTransformConstantFold('10/0')).toBe('10/0');
+            expect(ops.testTransformConstantFold('10%0')).toBe('10%0');
+        });
+        it('leaves non-finite results unchanged', () => {
+            const big = `1${'0'.repeat(200)}`;
+            const expr = `${big}*${big}`;
+            expect(ops.testTransformConstantFold(expr)).toBe(expr);
+        });
+        it('folds string concatenations and normalizes mixed quotes to single quotes', () => {
+            expect(ops.testTransformConstantFold(`'a'+'b'`)).toBe(`'ab'`);
+            expect(ops.testTransformConstantFold(`'a'+"b"`)).toBe(`'ab'`);
+        });
+        it('folds iteratively across rounds', () => {
+            expect(ops.testTransformConstantFold('1+2+3')).toBe('6');
+        });
+    });
+    describe('transformStringDecrypt', () => {
+        it('decodes hex escapes inside string literals', () => {
+            expect(ops.testTransformStringDecrypt("'\\x48\\x65\\x6c\\x6c\\x6f'")).toBe("'Hello'");
+        });
+        it('decodes unicode escapes inside string literals', () => {
+            expect(ops.testTransformStringDecrypt("'\\u0048\\u0065'")).toBe("'He'");
+        });
+        it('leaves already-plain strings unchanged', () => {
+            expect(ops.testTransformStringDecrypt(`'Hello'`)).toBe(`'Hello'`);
+        });
+    });
+    describe('transformDeadCodeRemove', () => {
+        it('replaces if(false){dead}else{live} with live body', () => {
+            expect(ops.testTransformDeadCodeRemove('if(false){dead}else{live}')).toBe('live');
+        });
+        it('removes if(false){dead} entirely', () => {
+            expect(ops.testTransformDeadCodeRemove('if(false){dead}')).toBe('');
+        });
+        it('removes if(0){dead} entirely', () => {
+            expect(ops.testTransformDeadCodeRemove('if(0){dead}')).toBe('');
+        });
+        it('leaves normal if statements unchanged', () => {
+            const code = 'if(x){dead}else{live}';
+            expect(ops.testTransformDeadCodeRemove(code)).toBe(code);
+        });
+    });
+    describe('transformControlFlowFlatten', () => {
+        it('rebuilds statements from standard switch dispatch pattern', () => {
+            const code = `var order="2|0|1".split("|");var i=0;while(!![]){switch(order[i++]){case "0":console.log("a");continue;case "1":console.log("b");continue;case "2":console.log("c");continue;}break;}`;
+            const expected = `console.log("c");\nconsole.log("a");\nconsole.log("b");`;
+            expect(ops.testTransformControlFlowFlatten(code)).toBe(expected);
+        });
+        it('returns unchanged when no pattern matches', () => {
+            const code = 'var x = 1; x++;';
+            expect(ops.testTransformControlFlowFlatten(code)).toBe(code);
+        });
+    });
+    describe('transformRenameVars', () => {
+        it('renames single-letter vars', () => {
+            const code = 'var a = 1; a + 2';
+            expect(ops.testTransformRenameVars(code)).toBe('var var_1 = 1; var_1 + 2');
+        });
+        it('leaves code unchanged when there are no single-letter var/let/const declarations', () => {
+            const code = 'var alpha = 1; alpha + 2';
+            expect(ops.testTransformRenameVars(code)).toBe(code);
+        });
+        it('does not rename after dots', () => {
+            const code = 'var a = 1; obj.a = a;';
+            const out = ops.testTransformRenameVars(code);
+            expect(out).toContain('obj.a');
+            expect(out).toContain('var var_1');
+        });
+    });
+    describe('applySingleTransform', () => {
+        it('dispatches constant_fold to transformConstantFold', () => {
+            expect(ops.testApplySingleTransform('1+2', 'constant_fold')).toBe('3');
+        });
+        it('dispatches string_decrypt to transformStringDecrypt', () => {
+            expect(ops.testApplySingleTransform("'\\x48\\x69'", 'string_decrypt')).toBe("'Hi'");
+        });
+        it('dispatches dead_code_remove to transformDeadCodeRemove', () => {
+            expect(ops.testApplySingleTransform('if(false){a}', 'dead_code_remove')).toBe('');
+        });
+        it('dispatches control_flow_flatten to transformControlFlowFlatten', () => {
+            const code = `var o="0".split("|");var i=0;while(!![]){switch(o[i++]){case "0":console.log("x");continue;}break;}`;
+            expect(ops.testApplySingleTransform(code, 'control_flow_flatten')).toBe(`console.log("x");`);
+        });
+        it('dispatches rename_vars to transformRenameVars', () => {
+            expect(ops.testApplySingleTransform('let a = 1; a;', 'rename_vars')).toBe('let var_1 = 1; var_1;');
+        });
+        it('returns code unchanged for unknown transform kind', () => {
+            const code = 'const x = 1;';
+            expect(ops.testApplySingleTransform(code, 'unknown')).toBe(code);
+        });
+    });
+    describe('applyTransforms', () => {
+        it('returns only actually-changed transforms in appliedTransforms', () => {
+            const result = ops.testApplyTransforms('const x = 1+2;', ['constant_fold', 'dead_code_remove']);
+            expect(result.transformed).toBe('const x = 3;');
+            expect(result.appliedTransforms).toEqual(['constant_fold']);
+        });
+        it('applies transforms in order', () => {
+            const code = 'if(false){var a=1;a;}else{var b=2;b;}';
+            const result = ops.testApplyTransforms(code, ['dead_code_remove', 'rename_vars']);
+            expect(result.appliedTransforms).toEqual(['dead_code_remove', 'rename_vars']);
+        });
+    });
+    describe('buildDiff', () => {
+        it('returns empty diff when strings are identical', () => {
+            expect(ops.testBuildDiff('a\nb', 'a\nb')).toBe('');
+        });
+        it('emits + and - lines when content differs', () => {
+            const diff = ops.testBuildDiff('a\nb\nc', 'a\nx\nc');
+            expect(diff).toContain('-b');
+            expect(diff).toContain('+x');
+        });
+        it('uses fallback diff for large inputs', () => {
+            const spy = vi.spyOn(ops, 'buildFallbackDiff');
+            const oldText = Array.from({ length: 600 }, (_, i) => `L${i}`).join('\n');
+            const newText = Array.from({ length: 600 }, (_, i) => (i === 300 ? `X${i}` : `L${i}`)).join('\n');
+            const diff = ops.testBuildDiff(oldText, newText);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(diff).toContain('-L300');
+            expect(diff).toContain('+X300');
+        });
+    });
+    describe('buildFallbackDiff', () => {
+        it('computes a minimal prefix/suffix diff', () => {
+            const diff = ops.testBuildFallbackDiff(['a', 'b', 'c'], ['a', 'x', 'c']);
+            expect(diff).toBe('-b\n+x');
+        });
+    });
+    describe('resolveTransformsForApply', () => {
+        it('uses parseTransforms when chainName is empty', () => {
+            expect(ops.testResolveTransformsForApply('', ['constant_fold', 'constant_fold'])).toEqual([
+                'constant_fold',
+            ]);
+        });
+        it('returns the chain transforms when chainName exists', () => {
+            ops.getChains().set('fast', {
+                name: 'fast',
+                transforms: ['constant_fold', 'dead_code_remove'],
+                createdAt: Date.now(),
+            });
+            expect(ops.testResolveTransformsForApply('fast', null)).toEqual([
+                'constant_fold',
+                'dead_code_remove',
+            ]);
+        });
+        it('throws when chainName is unknown', () => {
+            expect(() => ops.testResolveTransformsForApply('missing', ['constant_fold'])).toThrow('Transform chain not found: missing');
+        });
+    });
+});

package/dist/tests/server/domains/wasm/handlers.test.d.ts

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

package/dist/tests/server/domains/wasm/handlers.test.js

@@ -0,0 +1,107 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const runMock = vi.fn();
+const writeFileMock = vi.fn();
+const statMock = vi.fn();
+const resolveArtifactPathMock = vi.fn();
+vi.mock('node:fs/promises', () => ({
+    writeFile: (...args) => writeFileMock(...args),
+    stat: (...args) => statMock(...args),
+}));
+vi.mock('@src/utils/artifacts', () => ({
+    resolveArtifactPath: (...args) => resolveArtifactPathMock(...args),
+}));
+vi.mock('@src/modules/external/ToolRegistry', () => ({
+    ToolRegistry: class {
+    },
+}));
+vi.mock('@src/modules/external/ExternalToolRunner', () => ({
+    ExternalToolRunner: class {
+        run = runMock;
+    },
+}));
+import { WasmToolHandlers } from '../../../../src/server/domains/wasm/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('WasmToolHandlers', () => {
+    const page = {
+        evaluate: vi.fn(),
+    };
+    const collector = {
+        getActivePage: vi.fn(async () => page),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new WasmToolHandlers(collector);
+    });
+    it('returns wasm_dump error when no module is captured', async () => {
+        page.evaluate.mockResolvedValueOnce({ error: 'No WASM modules captured' });
+        const body = parseJson(await handlers.handleWasmDump({ moduleIndex: 0 }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('No WASM modules captured');
+    });
+    it('returns wasm_dump success with fallback message when bytes are unavailable', async () => {
+        page.evaluate
+            .mockResolvedValueOnce({
+            exports: ['a'],
+            importMods: ['env'],
+            size: 123,
+            moduleCount: 1,
+        })
+            .mockResolvedValueOnce(null);
+        const body = parseJson(await handlers.handleWasmDump({ moduleIndex: 0 }));
+        expect(body.success).toBe(true);
+        expect(body.artifactPath).toContain('binary not available');
+        expect(body.totalModules).toBe(1);
+    });
+    it('returns disassemble failure when external tool fails', async () => {
+        runMock.mockResolvedValue({
+            ok: false,
+            stderr: 'tool missing',
+            exitCode: 1,
+            stdout: '',
+            durationMs: 10,
+        });
+        const body = parseJson(await handlers.handleWasmDisassemble({ inputPath: 'a.wasm' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('tool missing');
+    });
+    it('writes disassembled output to artifact path on success', async () => {
+        resolveArtifactPathMock.mockResolvedValue({
+            absolutePath: '/tmp/out.wat',
+            displayPath: 'artifacts/out.wat',
+        });
+        runMock.mockResolvedValue({
+            ok: true,
+            stdout: '(module)\n(func)',
+            stderr: '',
+            exitCode: 0,
+            durationMs: 25,
+        });
+        const body = parseJson(await handlers.handleWasmDisassemble({ inputPath: 'a.wasm' }));
+        expect(writeFileMock).toHaveBeenCalledWith('/tmp/out.wat', '(module)\n(func)', 'utf-8');
+        expect(body.success).toBe(true);
+        expect(body.artifactPath).toBe('artifacts/out.wat');
+    });
+    it('computes wasm optimize size metrics', async () => {
+        resolveArtifactPathMock.mockResolvedValue({
+            absolutePath: '/tmp/out.wasm',
+            displayPath: 'artifacts/out.wasm',
+        });
+        runMock.mockResolvedValue({
+            ok: true,
+            stdout: '',
+            stderr: '',
+            exitCode: 0,
+            durationMs: 30,
+        });
+        statMock
+            .mockResolvedValueOnce({ size: 200 })
+            .mockResolvedValueOnce({ size: 100 });
+        const body = parseJson(await handlers.handleWasmOptimize({ inputPath: 'in.wasm', level: 'O2' }));
+        expect(body.success).toBe(true);
+        expect(body.inputSizeBytes).toBe(200);
+        expect(body.outputSizeBytes).toBe(100);
+    });
+});

package/dist/tests/server/domains/workflow/batch-register.test.d.ts

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