@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/server/workflows/WorkflowEngine.js

@@ -1,265 +0,0 @@
-import { randomUUID } from 'node:crypto';
-function extractConfigValue(config, path, fallback) {
-    const segments = path.split('.').filter(Boolean);
-    let current = config;
-    for (const segment of segments) {
-        if (!current || typeof current !== 'object')
-            return fallback;
-        current = current[segment];
-    }
-    return current ?? fallback;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withTimeout(promise, timeoutMs, label) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-        return promise;
-    }
-    return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-        promise.then((value) => {
-            clearTimeout(timeoutId);
-            resolve(value);
-        }, (error) => {
-            clearTimeout(timeoutId);
-            reject(error);
-        });
-    });
-}
-function parseToolPayload(response) {
-    if (!response || typeof response !== 'object')
-        return undefined;
-    const toolResponse = response;
-    const text = toolResponse.content?.find((item) => item.type === 'text')?.text;
-    if (typeof text !== 'string')
-        return undefined;
-    try {
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === 'object' ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function responseIndicatesFailure(response) {
-    if (!response || typeof response !== 'object')
-        return undefined;
-    const toolResponse = response;
-    if (toolResponse.isError) {
-        return 'Tool returned MCP error response';
-    }
-    const payload = parseToolPayload(response);
-    if (payload?.success === false) {
-        return typeof payload.error === 'string' ? payload.error : 'Tool reported success=false';
-    }
-    return undefined;
-}
-function collectSuccessStats(value) {
-    if (Array.isArray(value)) {
-        return value.reduce((acc, item) => {
-            const next = collectSuccessStats(item);
-            acc.success += next.success;
-            acc.failure += next.failure;
-            return acc;
-        }, { success: 0, failure: 0 });
-    }
-    if (!value || typeof value !== 'object') {
-        return { success: 0, failure: 0 };
-    }
-    const payload = parseToolPayload(value);
-    if (payload?.success === true)
-        return { success: 1, failure: 0 };
-    if (payload?.success === false)
-        return { success: 0, failure: 1 };
-    if ('error' in value) {
-        return { success: 0, failure: 1 };
-    }
-    return { success: 0, failure: 0 };
-}
-async function runToolNode(ctx, node, overrides) {
-    const mergedInput = {
-        ...(node.input ?? {}),
-        ...(overrides?.[node.id] ?? {}),
-    };
-    const runAttempt = async () => {
-        const response = await withTimeout(ctx.executeToolWithTracking(node.toolName, mergedInput), node.timeoutMs ?? 0, `Workflow tool node "${node.id}"`);
-        const failure = responseIndicatesFailure(response);
-        if (failure) {
-            throw new Error(failure);
-        }
-        return response;
-    };
-    const retry = node.retry;
-    if (!retry) {
-        return runAttempt();
-    }
-    let attempt = 0;
-    let backoffMs = retry.backoffMs;
-    while (attempt < retry.maxAttempts) {
-        try {
-            return await runAttempt();
-        }
-        catch (error) {
-            attempt += 1;
-            if (attempt >= retry.maxAttempts) {
-                throw error;
-            }
-            await sleep(backoffMs);
-            backoffMs = Math.max(0, Math.floor(backoffMs * (retry.multiplier ?? 1)));
-        }
-    }
-    throw new Error(`Workflow tool node "${node.id}" exhausted retries`);
-}
-async function runParallelNode(ctx, node, executionContext, options) {
-    const concurrency = Math.max(1, node.maxConcurrency ?? 4);
-    const results = new Array(node.steps.length);
-    let nextIndex = 0;
-    let stopped = false;
-    const worker = async () => {
-        while (true) {
-            if (stopped)
-                return;
-            const currentIndex = nextIndex;
-            nextIndex += 1;
-            if (currentIndex >= node.steps.length)
-                return;
-            const step = node.steps[currentIndex];
-            if (!step)
-                return;
-            try {
-                results[currentIndex] = await executeNode(ctx, step, executionContext, options);
-            }
-            catch (error) {
-                if (node.failFast) {
-                    stopped = true;
-                    throw error;
-                }
-                results[currentIndex] = {
-                    success: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-    };
-    await Promise.all(Array.from({ length: Math.min(concurrency, node.steps.length) }, () => worker()));
-    return results;
-}
-async function evaluatePredicate(node, ctx) {
-    if (node.predicateFn) {
-        return await node.predicateFn(ctx);
-    }
-    if (node.predicateId === 'always_true')
-        return true;
-    if (node.predicateId === 'always_false')
-        return false;
-    if (node.predicateId === 'any_step_failed') {
-        return [...ctx.stepResults.values()].some((value) => collectSuccessStats(value).failure > 0);
-    }
-    const successRateMatch = node.predicateId.match(/success_rate_gte_(\d+)/i);
-    if (successRateMatch) {
-        const threshold = Number(successRateMatch[1]);
-        const aggregate = [...ctx.stepResults.values()].reduce((acc, value) => {
-            const next = collectSuccessStats(value);
-            acc.success += next.success;
-            acc.failure += next.failure;
-            return acc;
-        }, { success: 0, failure: 0 });
-        const total = aggregate.success + aggregate.failure;
-        if (total === 0)
-            return false;
-        return aggregate.success / total >= threshold / 100;
-    }
-    throw new Error(`Unknown workflow predicateId "${node.predicateId}"`);
-}
-async function executeNode(ctx, node, executionContext, options) {
-    executionContext.emitSpan('workflow.node.start', { nodeId: node.id, kind: node.kind });
-    let result;
-    switch (node.kind) {
-        case 'tool':
-            result = await runToolNode(ctx, node, options.nodeInputOverrides);
-            break;
-        case 'sequence': {
-            const sequenceNode = node;
-            const items = [];
-            for (const step of sequenceNode.steps) {
-                items.push(await executeNode(ctx, step, executionContext, options));
-            }
-            result = items;
-            break;
-        }
-        case 'parallel':
-            result = await runParallelNode(ctx, node, executionContext, options);
-            break;
-        case 'branch': {
-            const branchNode = node;
-            const predicate = await evaluatePredicate(branchNode, executionContext);
-            const selected = predicate ? branchNode.whenTrue : branchNode.whenFalse;
-            if (selected) {
-                result = await executeNode(ctx, selected, executionContext, options);
-            }
-            else {
-                result = undefined;
-            }
-            break;
-        }
-        default:
-            throw new Error(`Unsupported workflow node kind: ${node.kind}`);
-    }
-    executionContext.stepResults.set(node.id, result);
-    executionContext.emitSpan('workflow.node.finish', { nodeId: node.id, kind: node.kind });
-    return result;
-}
-export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
-    const runId = randomUUID();
-    const profile = options.profile ?? String(ctx.currentTier ?? 'workflow');
-    const startedAt = new Date().toISOString();
-    const startedAtMs = Date.now();
-    const metrics = [];
-    const spans = [];
-    const stepResults = new Map();
-    const mergedConfig = options.config
-        ? { ...ctx.config, ...options.config }
-        : ctx.config;
-    const executionContext = {
-        workflowRunId: runId,
-        profile,
-        stepResults,
-        invokeTool(toolName, args) {
-            return ctx.executeToolWithTracking(toolName, args);
-        },
-        emitSpan(name, attrs) {
-            spans.push({ name, attrs, at: new Date().toISOString() });
-        },
-        emitMetric(name, value, type, attrs) {
-            metrics.push({ name, value, type, attrs, at: new Date().toISOString() });
-        },
-        getConfig(path, fallback) {
-            return extractConfigValue(mergedConfig, path, fallback);
-        },
-    };
-    try {
-        await workflow.onStart?.(executionContext);
-        const graph = workflow.build(executionContext);
-        const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
-        await workflow.onFinish?.(executionContext, result);
-        return {
-            workflowId: workflow.id,
-            displayName: workflow.displayName,
-            runId,
-            profile,
-            startedAt,
-            finishedAt: new Date().toISOString(),
-            durationMs: Date.now() - startedAtMs,
-            result,
-            stepResults: Object.fromEntries(stepResults.entries()),
-            metrics,
-            spans,
-        };
-    }
-    catch (error) {
-        const workflowError = error instanceof Error ? error : new Error(String(error));
-        await workflow.onError?.(executionContext, workflowError);
-        throw workflowError;
-    }
-}

package/dist/server/workflows/examples/batch-register.workflow.d.ts

@@ -1,3 +0,0 @@
-import type { WorkflowContract } from '../../workflows/WorkflowContract.js';
-declare const batchRegisterWorkflow: WorkflowContract;
-export default batchRegisterWorkflow;

package/dist/server/workflows/examples/batch-register.workflow.js

@@ -1,65 +0,0 @@
-import { branchNode, parallelNode, sequenceNode, toolNode, } from '../../workflows/WorkflowContract.js';
-const batchRegisterWorkflow = {
-    kind: 'workflow-contract',
-    version: 1,
-    id: 'workflow.batch-register.v1',
-    displayName: 'Batch Register Accounts',
-    description: 'Run register_account_flow for multiple accounts with concurrency controls, ' +
-        'retry policies, and success rate gating.',
-    tags: ['workflow', 'registration', 'batch', 'automation'],
-    timeoutMs: 15 * 60_000,
-    defaultMaxConcurrency: 3,
-    build(ctx) {
-        const maxConcurrency = ctx.getConfig('workflows.batchRegister.maxConcurrency', 3);
-        const precheck = toolNode('precheck', 'web_api_capture_session', {
-            input: {
-                url: 'about:blank',
-                exportHar: false,
-                exportReport: false,
-            },
-        });
-        const registerSteps = parallelNode('register-parallel', [
-            toolNode('register-account-1', 'register_account_flow', {
-                input: {
-                    registerUrl: 'https://example.com/register',
-                    fields: { username: 'user1', email: 'user1@temp.mail', password: '{{PLACEHOLDER}}' },
-                },
-                retry: { maxAttempts: 2, backoffMs: 1000, multiplier: 2 },
-            }),
-            toolNode('register-account-2', 'register_account_flow', {
-                input: {
-                    registerUrl: 'https://example.com/register',
-                    fields: { username: 'user2', email: 'user2@temp.mail', password: '{{PLACEHOLDER}}' },
-                },
-                retry: { maxAttempts: 2, backoffMs: 1000, multiplier: 2 },
-            }),
-        ], maxConcurrency, false);
-        const summarize = branchNode('summary-branch', 'batch_success_rate_gte_80', toolNode('success-summary', 'console_execute', {
-            input: { expression: '({ status: "batch_complete", successRate: ">=80%" })' },
-        }), toolNode('failure-summary', 'console_execute', {
-            input: { expression: '({ status: "needs_retry", successRate: "<80%", suggestion: "Check captcha provider or increase timeout" })' },
-        }), (_ctx) => {
-            return true;
-        });
-        return sequenceNode('batch-register-root', [precheck, registerSteps, summarize]);
-    },
-    onStart(ctx) {
-        ctx.emitMetric('workflow_runs_total', 1, 'counter', {
-            workflowId: 'workflow.batch-register.v1',
-            stage: 'start',
-        });
-    },
-    onFinish(ctx) {
-        ctx.emitMetric('workflow_runs_total', 1, 'counter', {
-            workflowId: 'workflow.batch-register.v1',
-            stage: 'finish',
-        });
-    },
-    onError(ctx, error) {
-        ctx.emitMetric('workflow_errors_total', 1, 'counter', {
-            workflowId: 'workflow.batch-register.v1',
-            error: error.name,
-        });
-    },
-};
-export default batchRegisterWorkflow;

package/dist/types/deobfuscator.d.ts

@@ -1,22 +0,0 @@
-export type ObfuscationType = 'javascript-obfuscator' | 'webpack' | 'uglify' | 'vm-protection' | 'self-modifying' | 'invisible-unicode' | 'control-flow-flattening' | 'string-array-rotation' | 'dead-code-injection' | 'opaque-predicates' | 'jsfuck' | 'aaencode' | 'jjencode' | 'packer' | 'eval-obfuscation' | 'base64-encoding' | 'hex-encoding' | 'jscrambler' | 'urlencoded' | 'custom' | 'unknown';
-export interface Transformation {
-    type: string;
-    description: string;
-    success: boolean;
-}
-export interface DeobfuscateOptions {
-    code: string;
-    llm?: 'gpt-4' | 'claude';
-    aggressive?: boolean;
-    preserveLogic?: boolean;
-    renameVariables?: boolean;
-    inlineFunctions?: boolean;
-}
-export interface DeobfuscateResult {
-    code: string;
-    readabilityScore: number;
-    confidence: number;
-    obfuscationType: ObfuscationType[];
-    transformations: Transformation[];
-    analysis: string;
-}

package/dist/types/index.d.ts

@@ -1,11 +0,0 @@
-export type { CodeLocation, Result } from './common.js';
-export type { Config, LLMConfig, PuppeteerConfig, MCPConfig, CacheConfig, PerformanceConfig, } from './config.js';
-export type { BrowserContext } from './browser.js';
-export type { CollectCodeOptions, CodeFile, CollectCodeResult, DependencyGraph, DependencyNode, DependencyEdge, } from './collector.js';
-export type { ObfuscationType, Transformation, DeobfuscateOptions, DeobfuscateResult, } from './deobfuscator.js';
-export type { UnderstandCodeOptions, UnderstandCodeResult, CodeStructure, TechStack, BusinessLogic, DataFlow, DataFlowGraph, DataFlowNode, DataFlowEdge, DataSource, DataSink, TaintPath, SecurityRisk, FunctionInfo, ClassInfo, PropertyInfo, ModuleInfo, CallGraph, CallGraphNode, CallGraphEdge, } from './analysis.js';
-export type { DetectCryptoOptions, DetectCryptoResult, CryptoAlgorithm, CryptoParameters, CryptoLibrary, } from './crypto.js';
-export type { HookOptions, HookCondition, HookHandler, HookContext, CallStackFrame, HookResult, HookRecord, } from './hook.js';
-export type { ScopeVariable, BreakpointHitEvent, BreakpointHitCallback, DebuggerSession, GetScopeVariablesOptions, GetScopeVariablesResult, Session, SessionData, } from './debugger.js';
-export type { DetectedEnvironmentVariables, MissingAPI, EmulationCode, EnvironmentEmulatorOptions, EnvironmentEmulatorResult, } from './emulator.js';
-export type { VMType, InstructionType, ComplexityLevel, VMInstruction, VMFeatures, UnresolvedPart, JSVMPDeobfuscatorOptions, JSVMPDeobfuscatorResult, } from './vm.js';

package/dist/utils/cliFastPath.js

@@ -1,54 +0,0 @@
-import { readFileSync } from 'node:fs';
-function getPackageVersion(moduleUrl) {
-    try {
-        const packageJsonUrl = new URL('../package.json', moduleUrl);
-        const packageJson = JSON.parse(readFileSync(packageJsonUrl, 'utf8'));
-        return packageJson.version ?? '0.0.0';
-    }
-    catch {
-        return process.env.npm_package_version ?? '0.0.0';
-    }
-}
-function buildHelpText(version) {
-    return [
-        `@jshookmcp/jshook ${version}`,
-        '',
-        'Usage:',
-        '  jshook [--help] [--version]',
-        '  jshookmcp [--help] [--version]',
-        '',
-        'Behavior:',
-        '  Starts the MCP server by default.',
-        '',
-        'Common environment variables:',
-        '  OPENAI_API_KEY',
-        '  DEFAULT_LLM_PROVIDER=openai|anthropic',
-        '  MCP_TRANSPORT=stdio|http',
-        '  MCP_TOOL_PROFILE=search|minimal|workflow|full',
-        '',
-    ].join('\n');
-}
-export function resolveCliFastPath(args, moduleUrl) {
-    const normalizedArgs = args.map((arg) => arg.trim()).filter(Boolean);
-    const showHelp = normalizedArgs.includes('--help') || normalizedArgs.includes('-h') || normalizedArgs[0] === 'help';
-    const showVersion = normalizedArgs.includes('--version') || normalizedArgs.includes('-v') || normalizedArgs.includes('-V') || normalizedArgs[0] === 'version';
-    if (showHelp) {
-        const version = getPackageVersion(moduleUrl);
-        return {
-            handled: true,
-            exitCode: 0,
-            output: buildHelpText(version),
-        };
-    }
-    if (showVersion) {
-        return {
-            handled: true,
-            exitCode: 0,
-            output: `${getPackageVersion(moduleUrl)}\n`,
-        };
-    }
-    return {
-        handled: false,
-        exitCode: 0,
-    };
-}

package/dist/utils/config.js

@@ -1,108 +0,0 @@
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { config as dotenvConfig } from 'dotenv';
-import { z } from 'zod';
-const currentFilename = fileURLToPath(import.meta.url);
-const currentDirname = dirname(currentFilename);
-export const projectRoot = join(currentDirname, '..', '..');
-const envPath = join(projectRoot, '.env');
-const result = dotenvConfig({ path: envPath, quiet: true });
-if (result.error) {
-    console.error('[Config] Warning: Failed to load .env file from configured path');
-    console.error(`[Config] Error: ${result.error.message}`);
-    console.error('[Config] Will use environment variables or defaults');
-}
-else if (process.env.DEBUG === 'true') {
-    console.info('[Config] .env file loaded (debug mode)');
-}
-const envInt = (fallback) => z.string().optional()
-    .transform((v) => (v ? parseInt(v, 10) : fallback))
-    .pipe(z.number().int().finite());
-const envBool = (fallback) => z.string().optional()
-    .transform((v) => (v === undefined ? fallback : v === 'true'));
-const ConfigSchema = z.object({
-    DEFAULT_LLM_PROVIDER: z.enum(['openai', 'anthropic']).optional().default('openai'),
-    OPENAI_API_KEY: z.string().optional().default(''),
-    OPENAI_MODEL: z.string().optional().default('gpt-4-turbo-preview'),
-    OPENAI_BASE_URL: z.string().optional(),
-    ANTHROPIC_API_KEY: z.string().optional().default(''),
-    ANTHROPIC_MODEL: z.string().optional().default('claude-3-5-sonnet-20241022'),
-    ANTHROPIC_BASE_URL: z.string().optional(),
-    PUPPETEER_HEADLESS: envBool(false),
-    PUPPETEER_TIMEOUT: envInt(30000).pipe(z.number().min(1000).max(300000)),
-    PUPPETEER_EXECUTABLE_PATH: z.string().optional(),
-    CHROME_PATH: z.string().optional(),
-    BROWSER_EXECUTABLE_PATH: z.string().optional(),
-    MCP_SERVER_NAME: z.string().optional().default('jshookmcp'),
-    MCP_SERVER_VERSION: z.string().optional().default('0.1.0'),
-    ENABLE_CACHE: envBool(false),
-    CACHE_DIR: z.string().optional().default('.cache'),
-    CACHE_TTL: envInt(3600).pipe(z.number().min(0)),
-    MAX_CONCURRENT_ANALYSIS: envInt(3).pipe(z.number().min(1).max(32)),
-    MAX_CODE_SIZE_MB: envInt(10).pipe(z.number().min(1).max(500)),
-});
-export function getConfig() {
-    const parsed = ConfigSchema.safeParse(process.env);
-    if (!parsed.success) {
-        const issues = parsed.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`);
-        console.error(`[Config] Validation errors:\n${issues.join('\n')}`);
-        console.error('[Config] Falling back to safe defaults for invalid fields');
-    }
-    const env = parsed.success ? parsed.data : process.env;
-    const cacheDir = env.CACHE_DIR || '.cache';
-    const configuredExecutablePath = (env.PUPPETEER_EXECUTABLE_PATH ||
-        env.CHROME_PATH ||
-        env.BROWSER_EXECUTABLE_PATH);
-    const absoluteCacheDir = cacheDir.startsWith('/') || cacheDir.match(/^[A-Za-z]:/)
-        ? cacheDir
-        : join(projectRoot, cacheDir);
-    return {
-        llm: {
-            provider: (env.DEFAULT_LLM_PROVIDER || 'openai'),
-            openai: {
-                apiKey: env.OPENAI_API_KEY || '',
-                model: env.OPENAI_MODEL || 'gpt-4-turbo-preview',
-                baseURL: env.OPENAI_BASE_URL,
-            },
-            anthropic: {
-                apiKey: env.ANTHROPIC_API_KEY || '',
-                model: env.ANTHROPIC_MODEL || 'claude-3-5-sonnet-20241022',
-                baseURL: env.ANTHROPIC_BASE_URL,
-            },
-        },
-        puppeteer: {
-            headless: parsed.success ? env.PUPPETEER_HEADLESS : process.env.PUPPETEER_HEADLESS === 'true',
-            timeout: parsed.success ? env.PUPPETEER_TIMEOUT : parseInt(process.env.PUPPETEER_TIMEOUT || '30000', 10),
-            executablePath: configuredExecutablePath?.trim() || undefined,
-        },
-        mcp: {
-            name: env.MCP_SERVER_NAME || 'jshookmcp',
-            version: env.MCP_SERVER_VERSION || '0.1.0',
-        },
-        cache: {
-            enabled: parsed.success ? env.ENABLE_CACHE : process.env.ENABLE_CACHE === 'true',
-            dir: absoluteCacheDir,
-            ttl: parsed.success ? env.CACHE_TTL : parseInt(process.env.CACHE_TTL || '3600', 10),
-        },
-        performance: {
-            maxConcurrentAnalysis: parsed.success ? env.MAX_CONCURRENT_ANALYSIS : parseInt(process.env.MAX_CONCURRENT_ANALYSIS || '3', 10),
-            maxCodeSizeMB: parsed.success ? env.MAX_CODE_SIZE_MB : parseInt(process.env.MAX_CODE_SIZE_MB || '10', 10),
-        },
-    };
-}
-export function validateConfig(config) {
-    const errors = [];
-    if (config.performance.maxConcurrentAnalysis < 1) {
-        errors.push('maxConcurrentAnalysis must be at least 1');
-    }
-    if (config.performance.maxCodeSizeMB < 1) {
-        errors.push('maxCodeSizeMB must be at least 1');
-    }
-    if (config.puppeteer.timeout < 1000) {
-        errors.push('puppeteer.timeout must be at least 1000ms');
-    }
-    if (config.cache.ttl < 0) {
-        errors.push('cache.ttl must be non-negative');
-    }
-    return { valid: errors.length === 0, errors };
-}