@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/workflows/WorkflowEngine.js

@@ -1,398 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { getEffectivePrerequisites } from '../ToolRouter.policy.js';
-import { getRoutingState } from '../ToolRouter.probe.js';
-class PreflightError extends Error {
-    warnings;
-    constructor(warnings) {
-        super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
-        this.warnings = warnings;
-        this.name = 'PreflightError';
-    }
-}
-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 };
-}
-function resolveInputFrom(mapping, stepResults) {
-    const resolved = {};
-    for (const [targetKey, sourceRef] of Object.entries(mapping)) {
-        const dotIndex = sourceRef.indexOf('.');
-        if (dotIndex === -1) {
-            resolved[targetKey] = stepResults.get(sourceRef);
-            continue;
-        }
-        const stepId = sourceRef.slice(0, dotIndex);
-        const fieldPath = sourceRef.slice(dotIndex + 1);
-        const stepResult = stepResults.get(stepId);
-        const payload = parseToolPayload(stepResult) ?? stepResult;
-        resolved[targetKey] = payload?.[fieldPath];
-    }
-    return resolved;
-}
-async function runToolNode(ctx, node, overrides, executionContext) {
-    const fromResolved = node.inputFrom
-        ? resolveInputFrom(node.inputFrom, executionContext.stepResults)
-        : {};
-    const mergedInput = {
-        ...node.input,
-        ...fromResolved,
-        ...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 = Array.from({ length: 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, executionContext);
-            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;
-}
-function collectToolNodes(node) {
-    switch (node.kind) {
-        case 'tool':
-            return [node];
-        case 'sequence':
-        case 'parallel':
-            return node.steps.flatMap((step) => collectToolNodes(step));
-        case 'branch':
-            return [
-                ...collectToolNodes(node.whenTrue),
-                ...(node.whenFalse ? collectToolNodes(node.whenFalse) : []),
-            ];
-        default:
-            return [];
-    }
-}
-function getEvidenceState(ctx) {
-    try {
-        const evidenceGraph = ctx.getDomainInstance('evidenceGraph');
-        return evidenceGraph
-            ? { hasGraph: true, nodeCount: evidenceGraph.nodeCount, edgeCount: evidenceGraph.edgeCount }
-            : { hasGraph: false, nodeCount: 0, edgeCount: 0 };
-    }
-    catch {
-        return { hasGraph: false, nodeCount: 0, edgeCount: 0 };
-    }
-}
-function collectUnsatisfiedPrerequisites(graph, routingState) {
-    const prerequisites = getEffectivePrerequisites();
-    const warnings = [];
-    for (const toolNode of collectToolNodes(graph)) {
-        const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
-        for (const prerequisite of toolPrerequisites) {
-            if (prerequisite.check(routingState)) {
-                continue;
-            }
-            warnings.push({
-                nodeId: toolNode.id,
-                toolName: toolNode.toolName,
-                condition: prerequisite.condition,
-                fix: prerequisite.fix,
-            });
-        }
-    }
-    return warnings;
-}
-export async function executeExtensionWorkflow(ctx, workflow, options = {}) {
-    const runId = randomUUID();
-    const profile = options.profile ?? String(ctx.baseTier ?? '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 preflightMode = options.preflightMode ?? 'warn';
-        let preflightWarnings = [];
-        if (preflightMode === 'skip') {
-            executionContext.emitSpan('workflow.preflight', {
-                mode: preflightMode,
-                skipped: true,
-                evidenceState: getEvidenceState(ctx),
-                warningCount: 0,
-            });
-        }
-        else {
-            try {
-                const routingState = await getRoutingState(ctx);
-                const evidenceState = getEvidenceState(ctx);
-                preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
-                executionContext.emitSpan('workflow.preflight', {
-                    mode: preflightMode,
-                    routingState,
-                    evidenceState,
-                    warningCount: preflightWarnings.length,
-                    warnings: preflightWarnings,
-                });
-                if (preflightMode === 'strict' && preflightWarnings.length > 0) {
-                    throw new PreflightError(preflightWarnings);
-                }
-            }
-            catch (error) {
-                if (error instanceof PreflightError) {
-                    throw error;
-                }
-                executionContext.emitSpan('workflow.preflight', {
-                    mode: preflightMode,
-                    warningCount: 0,
-                    skipped: true,
-                    error: error instanceof Error ? error.message : String(error),
-                    evidenceState: getEvidenceState(ctx),
-                });
-            }
-        }
-        const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
-        await workflow.onFinish?.(executionContext, result);
-        try {
-            const evidenceGraph = typeof ctx.getDomainInstance === 'function'
-                ? ctx.getDomainInstance('evidenceGraph')
-                : undefined;
-            if (evidenceGraph && evidenceGraph.nodeCount > 0) {
-                stepResults.set('__evidenceSnapshot', evidenceGraph.exportJson());
-                executionContext.emitSpan('workflow.evidence.auto-export', {
-                    nodeCount: evidenceGraph.nodeCount,
-                    edgeCount: evidenceGraph.edgeCount,
-                });
-            }
-        }
-        catch (exportError) {
-            executionContext.emitSpan('workflow.evidence.auto-export', {
-                skipped: true,
-                error: exportError instanceof Error ? exportError.message : String(exportError),
-            });
-        }
-        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/src/server/workflows/examples/batch-register.workflow.d.ts

@@ -1,2 +0,0 @@
-declare const batchRegisterWorkflow: import("../../workflows/WorkflowContract.js").WorkflowContract;
-export default batchRegisterWorkflow;

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

@@ -1,67 +0,0 @@
-import { createWorkflow, ToolNodeBuilder, SequenceNodeBuilder, } from '../../workflows/WorkflowContract.js';
-const batchRegisterWorkflow = createWorkflow('workflow.batch-register.v1', '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)
-    .buildGraph((ctx) => {
-    const maxConcurrency = ctx.getConfig('workflows.batchRegister.maxConcurrency', 3);
-    return new SequenceNodeBuilder('batch-register-root')
-        .tool('precheck', 'web_api_capture_session', (t) => t.input({
-        url: 'about:blank',
-        exportHar: false,
-        exportReport: false,
-    }))
-        .parallel('register-parallel', (p) => p
-        .maxConcurrency(maxConcurrency)
-        .failFast(false)
-        .tool('register-account-1', 'register_account_flow', (t) => t
-        .input({
-        registerUrl: 'https://example.com/register',
-        fields: {
-            username: 'user1',
-            email: 'user1@temp.mail',
-            password: '{{PLACEHOLDER}}',
-        },
-    })
-        .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 }))
-        .tool('register-account-2', 'register_account_flow', (t) => t
-        .input({
-        registerUrl: 'https://example.com/register',
-        fields: {
-            username: 'user2',
-            email: 'user2@temp.mail',
-            password: '{{PLACEHOLDER}}',
-        },
-    })
-        .retry({ maxAttempts: 2, backoffMs: 1000, multiplier: 2 })))
-        .branch('summary-branch', 'batch_success_rate_gte_80', (b) => b
-        .predicateFn((_ctx) => true)
-        .whenTrue(new ToolNodeBuilder('success-summary', 'console_execute').input({
-        expression: '({ status: "batch_complete", successRate: ">=80%" })',
-    }))
-        .whenFalse(new ToolNodeBuilder('failure-summary', 'console_execute').input({
-        expression: '({ status: "needs_retry", successRate: "<80%", suggestion: "Check captcha provider or increase timeout" })',
-    })));
-})
-    .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,
-    });
-})
-    .build();
-export default batchRegisterWorkflow;

package/dist/src/types/analysis.d.ts

@@ -1,135 +0,0 @@
-import type { CodeLocation } from './common.js';
-export interface UnderstandCodeOptions {
-    code: string;
-    context?: Record<string, unknown>;
-    focus?: 'structure' | 'business' | 'security' | 'all';
-}
-export interface UnderstandCodeResult {
-    structure: CodeStructure;
-    techStack: TechStack;
-    businessLogic: BusinessLogic;
-    dataFlow: DataFlow;
-    securityRisks: SecurityRisk[];
-    qualityScore: number;
-    codePatterns?: Array<{
-        name: string;
-        location: number;
-        description: string;
-    }>;
-    antiPatterns?: Array<{
-        name: string;
-        location: number;
-        severity: string;
-        recommendation: string;
-    }>;
-    complexityMetrics?: {
-        cyclomaticComplexity: number;
-        cognitiveComplexity: number;
-        maintainabilityIndex: number;
-        halsteadMetrics: {
-            vocabulary: number;
-            length: number;
-            difficulty: number;
-            effort: number;
-        };
-    };
-}
-export interface CodeStructure {
-    functions: FunctionInfo[];
-    classes: ClassInfo[];
-    modules: ModuleInfo[];
-    callGraph: CallGraph;
-}
-export interface FunctionInfo {
-    name: string;
-    params: string[];
-    returnType?: string;
-    location: CodeLocation;
-    complexity: number;
-}
-export interface ClassInfo {
-    name: string;
-    methods: FunctionInfo[];
-    properties: PropertyInfo[];
-    location: CodeLocation;
-}
-export interface PropertyInfo {
-    name: string;
-    type?: string;
-    value?: unknown;
-}
-export interface ModuleInfo {
-    name: string;
-    exports: string[];
-    imports: string[];
-}
-export interface CallGraph {
-    nodes: CallGraphNode[];
-    edges: CallGraphEdge[];
-}
-export interface CallGraphNode {
-    id: string;
-    name: string;
-    type: 'function' | 'method' | 'constructor';
-}
-export interface CallGraphEdge {
-    from: string;
-    to: string;
-    callCount?: number;
-}
-export interface TechStack {
-    framework?: string;
-    bundler?: string;
-    uiLibrary?: string;
-    stateManagement?: string;
-    cryptoLibrary?: string[];
-    other: string[];
-}
-export interface BusinessLogic {
-    mainFeatures: string[];
-    entities: string[];
-    rules: string[];
-    dataModel: Record<string, unknown>;
-}
-export interface DataFlow {
-    graph: DataFlowGraph;
-    sources: DataSource[];
-    sinks: DataSink[];
-    taintPaths: TaintPath[];
-}
-export interface DataFlowGraph {
-    nodes: DataFlowNode[];
-    edges: DataFlowEdge[];
-}
-export interface DataFlowNode {
-    id: string;
-    type: 'source' | 'sink' | 'transform';
-    name: string;
-    location: CodeLocation;
-}
-export interface DataFlowEdge {
-    from: string;
-    to: string;
-    data: string;
-}
-export interface DataSource {
-    type: 'user_input' | 'storage' | 'network' | 'other';
-    location: CodeLocation;
-}
-export interface DataSink {
-    type: 'dom' | 'network' | 'storage' | 'eval' | 'xss' | 'sql-injection' | 'other';
-    location: CodeLocation;
-}
-export interface TaintPath {
-    source: DataSource;
-    sink: DataSink;
-    path: CodeLocation[];
-    risk?: 'high' | 'medium' | 'low';
-}
-export interface SecurityRisk {
-    type: 'xss' | 'sql-injection' | 'csrf' | 'sensitive-data' | 'other';
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    location: CodeLocation;
-    description: string;
-    recommendation: string;
-}

package/dist/src/types/analysis.js

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

package/dist/src/types/browser.d.ts

@@ -1,16 +0,0 @@
-import type { Browser, Page } from 'rebrowser-puppeteer-core';
-export interface BrowserContext {
-    browser: Browser;
-    page: Page;
-    url: string;
-}
-declare global {
-    interface Window {
-        __aiHooks?: Record<string, unknown[]>;
-        __aiHookMetadata?: Record<string, {
-            id: string;
-            createdAt: number;
-            enabled: boolean;
-        }>;
-    }
-}

package/dist/src/types/browser.js

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

package/dist/src/types/collector.d.ts

@@ -1,56 +0,0 @@
-export interface CollectCodeOptions {
-    url: string;
-    depth?: number;
-    timeout?: number;
-    includeInline?: boolean;
-    includeExternal?: boolean;
-    includeDynamic?: boolean;
-    includeServiceWorker?: boolean;
-    includeWebWorker?: boolean;
-    filterRules?: string[];
-    smartMode?: 'summary' | 'priority' | 'incremental' | 'full';
-    compress?: boolean;
-    streaming?: boolean;
-    maxTotalSize?: number;
-    maxFileSize?: number;
-    priorities?: string[];
-}
-export interface CodeFile {
-    url: string;
-    content: string;
-    size: number;
-    type: 'inline' | 'external' | 'dynamic' | 'service-worker' | 'web-worker';
-    loadTime?: number;
-    metadata?: Record<string, unknown>;
-}
-export interface CollectCodeResult {
-    files: CodeFile[];
-    dependencies: DependencyGraph;
-    totalSize: number;
-    collectTime: number;
-    summaries?: Array<{
-        url: string;
-        size: number;
-        type: string;
-        hasEncryption: boolean;
-        hasAPI: boolean;
-        hasObfuscation: boolean;
-        functions: string[];
-        imports: string[];
-        preview: string;
-    }>;
-}
-export interface DependencyGraph {
-    nodes: DependencyNode[];
-    edges: DependencyEdge[];
-}
-export interface DependencyNode {
-    id: string;
-    url: string;
-    type: string;
-}
-export interface DependencyEdge {
-    from: string;
-    to: string;
-    type: 'import' | 'require' | 'script';
-}

package/dist/src/types/collector.js

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

package/dist/src/types/common.d.ts

@@ -1,11 +0,0 @@
-export interface CodeLocation {
-    file: string;
-    line: number;
-    column?: number;
-}
-export interface Result<T> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    message?: string;
-}