@jshookmcp/jshook 0.2.2 → 0.2.5

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;
@@ -30,4 +30,10 @@ export interface DomainManifest<TDepKey extends string = string, THandler = unkn
         readonly condition: string;
         readonly fix: string;
     }>>>;
+    readonly toolDependencies?: ReadonlyArray<{
+        readonly from: string;
+        readonly to: string;
+        readonly relation: 'requires' | 'precedes' | 'suggests';
+        readonly weight?: 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/MCPBridge.d.ts

@@ -1,9 +1,18 @@
 import type { MCPServerContext } from '../MCPServer.context.js';
+export interface BridgeCallRequest {
+    id: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
 export declare class MCPBridge {
     private readonly ctx;
     private allowlist;
+    private readonly pendingCalls;
     constructor(ctx: MCPServerContext);
     setAllowlist(toolNames: string[] | null): void;
+    enqueue(toolName: string, args?: Record<string, unknown>): string;
+    drainPending(): BridgeCallRequest[];
+    hasPending(): boolean;
     call(toolName: string, args?: Record<string, unknown>): Promise<unknown>;
     listAvailableTools(): string[];
 }

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

@@ -1,12 +1,34 @@
+import { randomUUID } from 'node:crypto';
 export class MCPBridge {
     ctx;
     allowlist = null;
+    pendingCalls = [];
     constructor(ctx) {
         this.ctx = ctx;
     }
     setAllowlist(toolNames) {
         this.allowlist = toolNames ? new Set(toolNames) : null;
     }
+    enqueue(toolName, args = {}) {
+        const registeredNames = this.ctx.selectedTools?.map((t) => t.name) ?? [];
+        if (!registeredNames.includes(toolName)) {
+            throw new Error(`Tool "${toolName}" is not a registered MCP tool`);
+        }
+        if (this.allowlist && !this.allowlist.has(toolName)) {
+            throw new Error(`Tool "${toolName}" is not in the sandbox allowlist`);
+        }
+        const id = randomUUID().slice(0, 8);
+        this.pendingCalls.push({ id, toolName, args });
+        return id;
+    }
+    drainPending() {
+        const calls = [...this.pendingCalls];
+        this.pendingCalls.length = 0;
+        return calls;
+    }
+    hasPending() {
+        return this.pendingCalls.length > 0;
+    }
     async call(toolName, args = {}) {
         if (this.allowlist && !this.allowlist.has(toolName)) {
             throw new Error(`Tool "${toolName}" is not in the sandbox allowlist`);

package/dist/src/server/sandbox/QuickJSSandbox.d.ts

@@ -1,11 +1,14 @@
-import type { SandboxOptions, SandboxResult } from '../sandbox/types.js';
+import type { SandboxOptions, SandboxResult, OrchestrationOptions, OrchestrationResult } from '../sandbox/types.js';
 import type { MCPBridge } from '../sandbox/MCPBridge.js';
 export declare class QuickJSSandbox {
     private bridge;
     setBridge(bridge: MCPBridge): void;
     execute(code: string, options?: SandboxOptions): Promise<SandboxResult>;
+    executeWithOrchestration(code: string, bridge: MCPBridge, options?: OrchestrationOptions): Promise<OrchestrationResult>;
+    private _executeOneRound;
     private _injectConsole;
     private _injectGlobals;
     private _injectHelpers;
     private _injectBridge;
+    private _injectBridgeForOrchestration;
 }