@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/server/instrumentation/types.js

@@ -0,0 +1,7 @@
+export var InstrumentationType;
+(function (InstrumentationType) {
+    InstrumentationType["BEFORE_LOAD_INJECT"] = "before-load-inject";
+    InstrumentationType["RUNTIME_HOOK"] = "runtime-hook";
+    InstrumentationType["NETWORK_INTERCEPT"] = "network-intercept";
+    InstrumentationType["FUNCTION_TRACE"] = "function-trace";
+})(InstrumentationType || (InstrumentationType = {}));

package/dist/src/server/macros/MacroConfigLoader.d.ts

@@ -14,9 +14,10 @@ interface MacroJsonSchema {
         optional?: boolean;
     }>;
 }
-export declare class MacroConfigLoader {
-    static loadFromDirectory(dir: string): Promise<MacroDefinition[]>;
-    static validate(raw: unknown): raw is MacroJsonSchema;
-    private static toDefinition;
-}
+declare function loadFromDirectory(dir: string): Promise<MacroDefinition[]>;
+declare function validate(raw: unknown): raw is MacroJsonSchema;
+export declare const MacroConfigLoader: {
+    readonly loadFromDirectory: typeof loadFromDirectory;
+    readonly validate: typeof validate;
+};
 export {};

package/dist/src/server/macros/MacroConfigLoader.js

@@ -1,71 +1,73 @@
 import { readdir, readFile } from 'node:fs/promises';
-import { resolve, extname } from 'node:path';
+import { extname, resolve } from 'node:path';
 import { logger } from '../../utils/logger.js';
-export class MacroConfigLoader {
-    static async loadFromDirectory(dir) {
-        let files;
+async function loadFromDirectory(dir) {
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const jsonFiles = files.filter((f) => extname(f) === '.json');
+    const macros = [];
+    for (const file of jsonFiles) {
+        const path = resolve(dir, file);
         try {
-            files = await readdir(dir);
-        }
-        catch {
-            return [];
-        }
-        const jsonFiles = files.filter((f) => extname(f) === '.json');
-        const macros = [];
-        for (const file of jsonFiles) {
-            const path = resolve(dir, file);
-            try {
-                const raw = JSON.parse(await readFile(path, 'utf-8'));
-                if (MacroConfigLoader.validate(raw)) {
-                    macros.push(MacroConfigLoader.toDefinition(raw));
-                    logger.info(`[macros] Loaded user macro "${raw.id}" from ${file}`);
-                }
-                else {
-                    logger.warn(`[macros] Skipping ${file}: invalid macro schema`);
-                }
+            const raw = JSON.parse(await readFile(path, 'utf-8'));
+            if (validate(raw)) {
+                macros.push(toDefinition(raw));
+                logger.info(`[macros] Loaded user macro "${raw.id}" from ${file}`);
             }
-            catch (err) {
-                logger.warn(`[macros] Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`);
+            else {
+                logger.warn(`[macros] Skipping ${file}: invalid macro schema`);
             }
         }
-        return macros;
+        catch (err) {
+            logger.warn(`[macros] Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
     }
-    static validate(raw) {
-        if (!raw || typeof raw !== 'object')
-            return false;
-        const obj = raw;
-        if (typeof obj.id !== 'string' || !obj.id)
+    return macros;
+}
+function validate(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const obj = raw;
+    if (typeof obj.id !== 'string' || !obj.id)
+        return false;
+    if (typeof obj.displayName !== 'string' || !obj.displayName)
+        return false;
+    if (!Array.isArray(obj.steps) || obj.steps.length === 0)
+        return false;
+    for (const step of obj.steps) {
+        if (!step || typeof step !== 'object')
             return false;
-        if (typeof obj.displayName !== 'string' || !obj.displayName)
+        const s = step;
+        if (typeof s.id !== 'string' || !s.id)
             return false;
-        if (!Array.isArray(obj.steps) || obj.steps.length === 0)
+        if (typeof s.toolName !== 'string' || !s.toolName)
             return false;
-        for (const step of obj.steps) {
-            if (!step || typeof step !== 'object')
-                return false;
-            const s = step;
-            if (typeof s.id !== 'string' || !s.id)
-                return false;
-            if (typeof s.toolName !== 'string' || !s.toolName)
-                return false;
-        }
-        return true;
-    }
-    static toDefinition(json) {
-        return {
-            id: json.id,
-            displayName: json.displayName,
-            description: json.description ?? '',
-            tags: json.tags ?? [],
-            timeoutMs: json.timeoutMs,
-            steps: json.steps.map((s) => ({
-                id: s.id,
-                toolName: s.toolName,
-                input: s.input,
-                inputFrom: s.inputFrom,
-                timeoutMs: s.timeoutMs,
-                optional: s.optional,
-            })),
-        };
     }
+    return true;
+}
+function toDefinition(json) {
+    return {
+        id: json.id,
+        displayName: json.displayName,
+        description: json.description ?? '',
+        tags: json.tags ?? [],
+        timeoutMs: json.timeoutMs,
+        steps: json.steps.map((s) => ({
+            id: s.id,
+            toolName: s.toolName,
+            input: s.input,
+            inputFrom: s.inputFrom,
+            timeoutMs: s.timeoutMs,
+            optional: s.optional,
+        })),
+    };
 }
+export const MacroConfigLoader = {
+    loadFromDirectory,
+    validate,
+};

package/dist/src/server/macros/MacroRunner.js

@@ -13,9 +13,13 @@ export class MacroRunner {
             .buildGraph(() => {
             const seq = new SequenceNodeBuilder(`${def.id}-root`);
             for (const step of def.steps) {
-                seq.step(new ToolNodeBuilder(step.id, step.toolName)
+                const toolBuilder = new ToolNodeBuilder(step.id, step.toolName)
                     .input(step.input ?? {})
-                    .timeout(step.timeoutMs ?? 0));
+                    .timeout(step.timeoutMs ?? 0);
+                if (step.inputFrom) {
+                    toolBuilder.inputFrom(step.inputFrom);
+                }
+                seq.step(toolBuilder);
             }
             return seq;
         })

package/dist/src/server/macros/builtins/index.d.ts

@@ -1,5 +1,4 @@
-import { deobfuscateAstFlow } from './deobfuscate-ast-flow.js';
-import { unpackerFlow } from './unpacker-flow.js';
 import type { MacroDefinition } from '../types.js';
+export declare const deobfuscateAstFlow: MacroDefinition;
+export declare const unpackerFlow: MacroDefinition;
 export declare const BUILTIN_MACROS: MacroDefinition[];
-export { deobfuscateAstFlow, unpackerFlow };

package/dist/src/server/macros/builtins/index.js

@@ -1,7 +1,51 @@
-import { deobfuscateAstFlow } from './deobfuscate-ast-flow.js';
-import { unpackerFlow } from './unpacker-flow.js';
-export const BUILTIN_MACROS = [
-    deobfuscateAstFlow,
-    unpackerFlow,
-];
-export { deobfuscateAstFlow, unpackerFlow };
+export const deobfuscateAstFlow = {
+    id: 'deobfuscate_ast_flow',
+    displayName: 'Deobfuscate AST Flow',
+    description: 'Chain: deobfuscate → advanced deobfuscation → extract function tree',
+    tags: ['analysis', 'deobfuscation', 'ast'],
+    timeoutMs: 60_000,
+    steps: [
+        {
+            id: 'deobfuscate',
+            toolName: 'deobfuscate',
+            input: {},
+        },
+        {
+            id: 'advanced_deobfuscate',
+            toolName: 'advanced_deobfuscate',
+            inputFrom: { code: 'deobfuscate.code' },
+            optional: true,
+        },
+        {
+            id: 'extract_functions',
+            toolName: 'extract_function_tree',
+            inputFrom: { code: 'deobfuscate.code' },
+        },
+    ],
+};
+export const unpackerFlow = {
+    id: 'unpacker_flow',
+    displayName: 'Unpacker Flow',
+    description: 'Detect packer type → extract inner code → deobfuscate → beautify output',
+    tags: ['analysis', 'unpacking', 'deobfuscation'],
+    timeoutMs: 90_000,
+    steps: [
+        {
+            id: 'detect_and_unpack',
+            toolName: 'deobfuscate',
+            input: { unpack: true },
+        },
+        {
+            id: 'deep_deobfuscate',
+            toolName: 'advanced_deobfuscate',
+            inputFrom: { code: 'detect_and_unpack.code' },
+            optional: true,
+        },
+        {
+            id: 'beautify',
+            toolName: 'ast_transform_beautify',
+            inputFrom: { code: 'detect_and_unpack.code' },
+        },
+    ],
+};
+export const BUILTIN_MACROS = [deobfuscateAstFlow, unpackerFlow];

package/dist/src/server/plugins/PluginContract.d.ts

@@ -1 +1 @@
-export { type ToolProfileId, type ToolArgs, type ToolResponse, type PluginState, type PluginLifecycleContext, type ExtensionToolHandler, type ExtensionToolDefinition, ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';
+export { type ToolProfileId, type ToolArgs, type ToolResponse, type PluginState, type PluginLifecycleContext, type ExtensionToolHandler, type ExtensionToolDefinition, type ExtensionWorkflowDefinition, ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';

package/dist/src/server/registry/contracts.d.ts

@@ -19,7 +19,7 @@ export interface DomainManifest<TDepKey extends string = string, THandler = unkn
     readonly secondaryDepKeys?: readonly string[];
     readonly profiles: readonly ToolProfileId[];
     readonly registrations: readonly ToolRegistration[];
-    readonly ensure: (ctx: MCPServerContext) => THandler;
+    readonly ensure: (ctx: MCPServerContext) => THandler | Promise<THandler>;
     readonly workflowRule?: {
         readonly patterns: readonly RegExp[];
         readonly priority: number;

package/dist/src/server/registry/discovery.js

@@ -1,7 +1,9 @@
 import { readdir, stat } from 'node:fs/promises';
-import { dirname, join, relative, sep } from 'node:path';
+import { join, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { logger } from '../../utils/logger.js';
+const registryDirUrl = new URL('.', import.meta.url);
+const registryDir = fileURLToPath(registryDirUrl);
 function isDomainManifest(value) {
     if (!value || typeof value !== 'object')
         return false;
@@ -26,7 +28,7 @@ function extractManifest(mod) {
     return null;
 }
 async function discoverManifestPaths() {
-    const domainsDir = fileURLToPath(new URL('../domains/', import.meta.url));
+    const domainsDir = fileURLToPath(new URL('../domains/', registryDirUrl));
     let entries;
     try {
         entries = await readdir(domainsDir, { withFileTypes: true });
@@ -52,8 +54,7 @@ async function discoverManifestPaths() {
     return resolved.filter((value) => value !== null);
 }
 function toImportSpecifier(absPath) {
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    const relPath = relative(currentDir, absPath).split(sep).join('/');
+    const relPath = relative(registryDir, absPath).split(sep).join('/');
     if (relPath.startsWith('.')) {
         return relPath;
     }

package/dist/src/server/registry/ensure-browser-core.js

@@ -3,7 +3,6 @@ import { PageController } from '../../modules/collector/PageController.js';
 import { DOMInspector } from '../../modules/collector/DOMInspector.js';
 import { ScriptManager } from '../../modules/debugger/ScriptManager.js';
 import { ConsoleMonitor } from '../../modules/monitor/ConsoleMonitor.js';
-import { LLMService } from '../../services/LLMService.js';
 export function ensureBrowserCore(ctx) {
     if (!ctx.collector) {
         ctx.collector = new CodeCollector(ctx.config.puppeteer);
@@ -17,6 +16,4 @@ export function ensureBrowserCore(ctx) {
         ctx.scriptManager = new ScriptManager(ctx.collector);
     if (!ctx.consoleMonitor)
         ctx.consoleMonitor = new ConsoleMonitor(ctx.collector);
-    if (!ctx.llm)
-        ctx.llm = new LLMService(ctx.config.llm);
 }

package/dist/src/server/registry/index.js

@@ -1,3 +1,7 @@
+function isSubset(a, b) {
+    const bSet = new Set(b);
+    return a.every((x) => bSet.has(x));
+}
 import { discoverDomainManifests } from '../registry/discovery.js';
 import { logger } from '../../utils/logger.js';
 let _manifests = null;
@@ -109,10 +113,6 @@ export function buildProfileDomains() {
     for (const [p, domains] of Object.entries(profiles)) {
         result[p] = [...domains];
     }
-    const isSubset = (a, b) => {
-        const bSet = new Set(b);
-        return a.every((x) => bSet.has(x));
-    };
     if (!isSubset(result['search'], result['workflow'])) {
         logger.warn('[registry] Profile hierarchy: search not subset of workflow');
     }

package/dist/src/server/registry/tool-builder.d.ts

@@ -0,0 +1,46 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
+interface PropertySchema {
+    type?: JsonSchemaType;
+    description?: string;
+    default?: unknown;
+    enum?: readonly string[];
+    items?: PropertySchema | Record<string, unknown>;
+    properties?: Record<string, PropertySchema>;
+    required?: string[];
+    [key: string]: unknown;
+}
+interface ParamOpts {
+    default?: unknown;
+}
+declare class ToolBuilder {
+    private readonly _name;
+    private _description;
+    private readonly _properties;
+    private readonly _required;
+    private _readOnlyHint;
+    private _destructiveHint;
+    private _idempotentHint;
+    private _openWorldHint;
+    constructor(name: string);
+    desc(description: string): this;
+    string(name: string, description: string, opts?: ParamOpts): this;
+    number(name: string, description: string, opts?: ParamOpts): this;
+    integer(name: string, description: string, opts?: ParamOpts): this;
+    boolean(name: string, description: string, opts?: ParamOpts): this;
+    enum(name: string, values: readonly string[], description: string, opts?: ParamOpts): this;
+    array(name: string, items: PropertySchema | Record<string, unknown>, description: string): this;
+    object(name: string, props: Record<string, PropertySchema>, description: string, opts?: {
+        required?: string[];
+    }): this;
+    prop(name: string, schema: PropertySchema): this;
+    required(...names: string[]): this;
+    readOnly(): this;
+    destructive(): this;
+    idempotent(): this;
+    openWorld(): this;
+    build(): Tool;
+    private defaults;
+}
+export declare function tool(name: string): ToolBuilder;
+export {};

package/dist/src/server/registry/tool-builder.js

@@ -0,0 +1,105 @@
+class ToolBuilder {
+    _name;
+    _description = '';
+    _properties = {};
+    _required = [];
+    _readOnlyHint = false;
+    _destructiveHint = false;
+    _idempotentHint = false;
+    _openWorldHint = false;
+    constructor(name) {
+        this._name = name;
+    }
+    desc(description) {
+        this._description = description;
+        return this;
+    }
+    string(name, description, opts) {
+        this._properties[name] = { type: 'string', description, ...this.defaults(opts) };
+        return this;
+    }
+    number(name, description, opts) {
+        this._properties[name] = { type: 'number', description, ...this.defaults(opts) };
+        return this;
+    }
+    integer(name, description, opts) {
+        this._properties[name] = { type: 'integer', description, ...this.defaults(opts) };
+        return this;
+    }
+    boolean(name, description, opts) {
+        this._properties[name] = { type: 'boolean', description, ...this.defaults(opts) };
+        return this;
+    }
+    enum(name, values, description, opts) {
+        this._properties[name] = {
+            type: 'string',
+            enum: values,
+            description,
+            ...this.defaults(opts),
+        };
+        return this;
+    }
+    array(name, items, description) {
+        this._properties[name] = { type: 'array', items, description };
+        return this;
+    }
+    object(name, props, description, opts) {
+        this._properties[name] = {
+            type: 'object',
+            properties: props,
+            description,
+            ...(opts?.required ? { required: opts.required } : {}),
+        };
+        return this;
+    }
+    prop(name, schema) {
+        this._properties[name] = schema;
+        return this;
+    }
+    required(...names) {
+        this._required.push(...names);
+        return this;
+    }
+    readOnly() {
+        this._readOnlyHint = true;
+        return this;
+    }
+    destructive() {
+        this._destructiveHint = true;
+        return this;
+    }
+    idempotent() {
+        this._idempotentHint = true;
+        return this;
+    }
+    openWorld() {
+        this._openWorldHint = true;
+        return this;
+    }
+    build() {
+        const result = {
+            name: this._name,
+            description: this._description,
+            inputSchema: {
+                type: 'object',
+                properties: this._properties,
+                ...(this._required.length > 0 ? { required: this._required } : {}),
+            },
+            annotations: {
+                readOnlyHint: this._readOnlyHint,
+                destructiveHint: this._destructiveHint,
+                idempotentHint: this._idempotentHint,
+                openWorldHint: this._openWorldHint,
+            },
+        };
+        return result;
+    }
+    defaults(opts) {
+        if (opts?.default === undefined)
+            return {};
+        return { default: opts.default };
+    }
+}
+export function tool(name) {
+    return new ToolBuilder(name);
+}

package/dist/src/server/sandbox/QuickJSSandbox.js

@@ -1,7 +1,8 @@
 import { getQuickJS } from 'quickjs-emscripten';
 import { SANDBOX_HELPER_SOURCE } from '../sandbox/SandboxHelpers.js';
-const DEFAULT_TIMEOUT_MS = 1_000;
-const DEFAULT_MEMORY_LIMIT_BYTES = 8 * 1024 * 1024;
+import { SANDBOX_EXEC_TIMEOUT_MS, SANDBOX_MEMORY_LIMIT_MB } from '../../constants.js';
+const DEFAULT_TIMEOUT_MS = SANDBOX_EXEC_TIMEOUT_MS;
+const DEFAULT_MEMORY_LIMIT_BYTES = SANDBOX_MEMORY_LIMIT_MB * 1024 * 1024;
 const DEFAULT_MAX_BRIDGE_CALLS = 10;
 function marshalToQuickJS(ctx, value) {
     if (value === null || value === undefined)
@@ -143,7 +144,7 @@ export class QuickJSSandbox {
         let round = 0;
         while (round <= maxBridgeCalls) {
             const roundGlobals = {
-                ...(options.globals ?? {}),
+                ...options.globals,
                 __bridgeRound: round,
             };
             if (round > 0) {
@@ -178,7 +179,11 @@ export class QuickJSSandbox {
                 catch (err) {
                     const errorMsg = err instanceof Error ? err.message : String(err);
                     roundResults[req.id] = { __error: true, message: errorMsg };
-                    allBridgeCalls.push({ toolName: req.toolName, args: req.args, result: { __error: true, message: errorMsg } });
+                    allBridgeCalls.push({
+                        toolName: req.toolName,
+                        args: req.args,
+                        result: { __error: true, message: errorMsg },
+                    });
                 }
             }
             bridgeResults = { ...bridgeResults, ...roundResults };
@@ -223,7 +228,13 @@ export class QuickJSSandbox {
                 const errorMsg = context.dump(result.error);
                 result.error.dispose();
                 if (timedOut) {
-                    return { ok: false, error: 'Execution timed out', timedOut: true, durationMs: Date.now() - startTime, logs };
+                    return {
+                        ok: false,
+                        error: 'Execution timed out',
+                        timedOut: true,
+                        durationMs: Date.now() - startTime,
+                        logs,
+                    };
                 }
                 return {
                     ok: false,