@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/modules/deobfuscator/VMDeobfuscator.js

@@ -1,5 +1,6 @@
 import { logger } from '../../utils/logger.js';
 import { VM_DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
+import {} from '../../services/LLMService.js';
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
@@ -135,87 +136,87 @@ export class VMDeobfuscator {
     }
     buildVMDeobfuscationPrompt(code, vmInfo, vmStructure, vmComponents) {
         const codeSnippet = code.length > 2000 ? code.slice(0, 2000) + '\n...(truncated)' : code;
-        return `# VM Deobfuscation Analysis
-
-## VM Profile
-- **Architecture**: ${vmInfo.type}
-- **Instruction Count**: ${vmInfo.instructionCount}
-- **Interpreter Loop**: ${vmStructure.hasInterpreter ? 'Detected' : 'Not detected'}
-- **Stack Operations**: ${vmStructure.hasStack ? 'Present' : 'Absent'}
-- **Register Usage**: ${vmStructure.hasRegisters ? 'Present' : 'Absent'}
-- **Instruction Variety**: ${vmStructure.instructionTypes.length} distinct types
-
-## Identified Components
-${vmComponents.instructionArray ? ` Instruction Array: Found at ${vmComponents.instructionArray}` : ' Instruction Array: Not found'}
-${vmComponents.dataArray ? ` Data Array: Found at ${vmComponents.dataArray}` : ' Data Array: Not found'}
-${vmComponents.interpreterFunction ? ` Interpreter Function: Found at ${vmComponents.interpreterFunction}` : ' Interpreter Function: Not found'}
-
-## VM-Protected Code
-\`\`\`javascript
-${codeSnippet}
-\`\`\`
-
-## Deobfuscation Instructions (Chain-of-Thought)
-
-### Step 1: VM Structure Analysis
-Examine the code to identify:
-- Instruction array (usually a large array of numbers/strings)
-- Interpreter loop (while/for loop processing instructions)
-- Stack/register variables
-- Opcode handlers (switch-case or if-else chains)
-
-### Step 2: Instruction Decoding
-For each instruction type, determine:
-- What JavaScript operation it represents (e.g., opcode 0x01 = addition)
-- How it manipulates the stack/registers
-- What side effects it has (function calls, property access, etc.)
-
-### Step 3: Control Flow Reconstruction
-- Map VM jumps/branches to JavaScript if/while/for statements
-- Identify function calls and returns
-- Reconstruct try-catch blocks if present
-
-### Step 4: Code Generation
-- Replace VM instruction sequences with equivalent JavaScript
-- Use meaningful variable names based on usage context
-- Remove VM overhead (interpreter loop, stack management)
-- Preserve all side effects and program behavior
-
-### Step 5: Validation
-- Ensure output is syntactically valid JavaScript
-- Verify no functionality is lost
-- Add comments for complex patterns
-
-## Example Transformation (Few-shot Learning)
-
-**VM Code (Before)**:
-\`\`\`javascript
-var vm = [0x01, 0x05, 0x02, 0x03, 0x10];
-var stack = [];
-for(var i=0; i<vm.length; i++) {
-  switch(vm[i]) {
-    case 0x01: stack.push(5); break;
-    case 0x02: stack.push(3); break;
-    case 0x10: var b=stack.pop(), a=stack.pop(); stack.push(a+b); break;
-  }
-}
-console.log(stack[0]);
-\`\`\`
-
-**Deobfuscated Code (After)**:
-\`\`\`javascript
-var result = 5 + 3;
-console.log(result);
-\`\`\`
-
-## Critical Requirements
-1. Output ONLY the deobfuscated JavaScript code
-2. NO markdown code blocks, NO explanations, NO comments outside the code
-3. Code must be syntactically valid and executable
-4. Preserve exact program logic and side effects
-5. If full deobfuscation is impossible, return the best partial result
-
-## Output Format
+        return `# VM Deobfuscation Analysis
+
+## VM Profile
+- **Architecture**: ${vmInfo.type}
+- **Instruction Count**: ${vmInfo.instructionCount}
+- **Interpreter Loop**: ${vmStructure.hasInterpreter ? 'Detected' : 'Not detected'}
+- **Stack Operations**: ${vmStructure.hasStack ? 'Present' : 'Absent'}
+- **Register Usage**: ${vmStructure.hasRegisters ? 'Present' : 'Absent'}
+- **Instruction Variety**: ${vmStructure.instructionTypes.length} distinct types
+
+## Identified Components
+${vmComponents.instructionArray ? ` Instruction Array: Found at ${vmComponents.instructionArray}` : ' Instruction Array: Not found'}
+${vmComponents.dataArray ? ` Data Array: Found at ${vmComponents.dataArray}` : ' Data Array: Not found'}
+${vmComponents.interpreterFunction ? ` Interpreter Function: Found at ${vmComponents.interpreterFunction}` : ' Interpreter Function: Not found'}
+
+## VM-Protected Code
+\`\`\`javascript
+${codeSnippet}
+\`\`\`
+
+## Deobfuscation Instructions (Chain-of-Thought)
+
+### Step 1: VM Structure Analysis
+Examine the code to identify:
+- Instruction array (usually a large array of numbers/strings)
+- Interpreter loop (while/for loop processing instructions)
+- Stack/register variables
+- Opcode handlers (switch-case or if-else chains)
+
+### Step 2: Instruction Decoding
+For each instruction type, determine:
+- What JavaScript operation it represents (e.g., opcode 0x01 = addition)
+- How it manipulates the stack/registers
+- What side effects it has (function calls, property access, etc.)
+
+### Step 3: Control Flow Reconstruction
+- Map VM jumps/branches to JavaScript if/while/for statements
+- Identify function calls and returns
+- Reconstruct try-catch blocks if present
+
+### Step 4: Code Generation
+- Replace VM instruction sequences with equivalent JavaScript
+- Use meaningful variable names based on usage context
+- Remove VM overhead (interpreter loop, stack management)
+- Preserve all side effects and program behavior
+
+### Step 5: Validation
+- Ensure output is syntactically valid JavaScript
+- Verify no functionality is lost
+- Add comments for complex patterns
+
+## Example Transformation (Few-shot Learning)
+
+**VM Code (Before)**:
+\`\`\`javascript
+var vm = [0x01, 0x05, 0x02, 0x03, 0x10];
+var stack = [];
+for(var i=0; i<vm.length; i++) {
+  switch(vm[i]) {
+    case 0x01: stack.push(5); break;
+    case 0x02: stack.push(3); break;
+    case 0x10: var b=stack.pop(), a=stack.pop(); stack.push(a+b); break;
+  }
+}
+console.log(stack[0]);
+\`\`\`
+
+**Deobfuscated Code (After)**:
+\`\`\`javascript
+var result = 5 + 3;
+console.log(result);
+\`\`\`
+
+## Critical Requirements
+1. Output ONLY the deobfuscated JavaScript code
+2. NO markdown code blocks, NO explanations, NO comments outside the code
+3. Code must be syntactically valid and executable
+4. Preserve exact program logic and side effects
+5. If full deobfuscation is impossible, return the best partial result
+
+## Output Format
 Return clean JavaScript code starting immediately (no preamble).`;
     }
     simplifyVMCode(code, vmComponents) {

package/dist/src/modules/deobfuscator/webcrack.js

@@ -126,7 +126,9 @@ export async function runWebcrack(code, options) {
             unminify: optionsUsed.unminify,
             mangle: optionsUsed.mangle,
         });
-        const remapped = result.bundle ? applyBundleMappings(result.bundle, options.mappings) : new Map();
+        const remapped = result.bundle
+            ? applyBundleMappings(result.bundle, options.mappings)
+            : new Map();
         let savedTo;
         let savedArtifacts;
         if (typeof options.outputDir === 'string' && options.outputDir.trim().length > 0) {

package/dist/src/modules/detector/ObfuscationDetector.d.ts

@@ -1,4 +1,4 @@
-import { ObfuscationType, VMFeatures } from '../../types/index.js';
+import type { ObfuscationType, VMFeatures } from '../../types/index.js';
 export interface DetectionResult {
     types: ObfuscationType[];
     confidence: Record<ObfuscationType, number>;

package/dist/src/modules/emulator/AIEnvironmentAnalyzer.js

@@ -79,7 +79,7 @@ export class AIEnvironmentAnalyzer {
         try {
             const response = await this.llm.chat(generateAPIImplementationMessages(apiPath, context));
             const codeMatch = response.content.match(/```(?:javascript|js)?\s*([\s\S]*?)\s*```/);
-            if (codeMatch && codeMatch[1]) {
+            if (codeMatch?.[1]) {
                 return codeMatch[1].trim();
             }
             const trimmed = response.content.trim();

package/dist/src/modules/emulator/EmulatorCodeGen.js

@@ -303,8 +303,7 @@ function isFunctionMarker(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
     }
-    return ('__type' in value &&
-        value.__type === 'Function');
+    return '__type' in value && value.__type === 'Function';
 }
 export function formatValue(value) {
     if (value === null)

package/dist/src/modules/emulator/EnvironmentEmulator.js

@@ -386,10 +386,10 @@ export class EnvironmentEmulator {
         return typeof value === 'object' && value !== null;
     }
     isIdentifierNode(node) {
-        return (this.isRecord(node) && node.type === 'Identifier' && typeof node.name === 'string');
+        return this.isRecord(node) && node.type === 'Identifier' && typeof node.name === 'string';
     }
     isStringLiteralNode(node) {
-        return (this.isRecord(node) && node.type === 'StringLiteral' && typeof node.value === 'string');
+        return this.isRecord(node) && node.type === 'StringLiteral' && typeof node.value === 'string';
     }
     isMemberExpressionNode(node) {
         return (this.isRecord(node) &&

package/dist/src/modules/external/ExternalToolRunner.d.ts

@@ -1,4 +1,4 @@
-import { ToolRegistry } from '../external/ToolRegistry.js';
+import { type ToolRegistry } from '../external/ToolRegistry.js';
 import type { ToolRunRequest, ToolRunResult } from '../external/types.js';
 export declare class ExternalToolRunner {
     private readonly registry;

package/dist/src/modules/external/ExternalToolRunner.js

@@ -3,6 +3,7 @@ import { resolve, relative, sep } from 'node:path';
 import { getProjectRoot } from '../../utils/outputPaths.js';
 import { logger } from '../../utils/logger.js';
 import { ioLimit } from '../../utils/concurrency.js';
+import {} from '../external/ToolRegistry.js';
 import { EXTERNAL_TOOL_TIMEOUT_MS, EXTERNAL_TOOL_MAX_STDOUT_BYTES, EXTERNAL_TOOL_MAX_STDERR_BYTES, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS, } from '../../constants.js';
 const DEFAULT_TIMEOUT_MS = EXTERNAL_TOOL_TIMEOUT_MS;
 const DEFAULT_MAX_STDOUT = EXTERNAL_TOOL_MAX_STDOUT_BYTES;
@@ -155,12 +156,7 @@ export class ExternalToolRunner {
         if (rel && !rel.startsWith('..') && !resolve(rel).startsWith(sep)) {
             return resolved;
         }
-        const tmpDirs = [
-            process.env.TEMP,
-            process.env.TMP,
-            '/tmp',
-            '/var/tmp',
-        ].filter(Boolean);
+        const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);
         for (const tmp of tmpDirs) {
             if (!tmp)
                 continue;

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.compose.js

@@ -1,9 +1,9 @@
 export function generateHookChain(hooks) {
     const scripts = hooks.map((h) => h.script).join('\n\n');
-    return `
-
-${scripts}
-
-console.log('[Hook Chain] All ${hooks.length} hooks initialized');
+    return `
+
+${scripts}
+
+console.log('[Hook Chain] All ${hooks.length} hooks initialized');
 `.trim();
 }