@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,269 +0,0 @@
-import { InstrumentationType } from './types.js';
-let _nextId = 0;
-function uid(prefix) {
-    return `${prefix}-${Date.now().toString(36)}-${(++_nextId).toString(36)}`;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function parseToolPayload(response) {
-    const firstText = response.content.find((item) => item.type === 'text' && typeof item.text === 'string');
-    if (!firstText) {
-        throw new Error('Expected JSON text payload from wrapped tool response');
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(firstText.text);
-    }
-    catch (error) {
-        throw new Error(`Wrapped tool returned non-JSON text payload: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-    if (!isRecord(parsed)) {
-        throw new Error('Wrapped tool returned JSON that is not an object');
-    }
-    return parsed;
-}
-function getStringArray(value) {
-    return Array.isArray(value)
-        ? value.filter((item) => typeof item === 'string')
-        : [];
-}
-export class InstrumentationSessionManager {
-    sessions = new Map();
-    operations = new Map();
-    artifacts = new Map();
-    operationIndex = new Map();
-    evidenceBridge;
-    setEvidenceBridge(bridge) {
-        this.evidenceBridge = bridge;
-    }
-    createSession(name) {
-        const id = uid('sess');
-        const info = {
-            id,
-            name,
-            createdAt: Date.now(),
-            operationCount: 0,
-            artifactCount: 0,
-            status: 'active',
-        };
-        this.sessions.set(id, info);
-        this.operations.set(id, []);
-        this.artifacts.set(id, []);
-        return info;
-    }
-    destroySession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            throw new Error(`Session "${sessionId}" not found`);
-        session.status = 'destroyed';
-        const ops = this.operations.get(sessionId) ?? [];
-        for (const op of ops) {
-            if (op.status === 'active')
-                op.status = 'completed';
-        }
-    }
-    listSessions() {
-        return [...this.sessions.values()].filter((s) => s.status === 'active');
-    }
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    registerOperation(sessionId, type, target, config) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            throw new Error(`Session "${sessionId}" not found`);
-        if (session.status === 'destroyed') {
-            throw new Error(`Session "${sessionId}" is destroyed — cannot register new operations`);
-        }
-        const id = uid('op');
-        const op = {
-            id,
-            sessionId,
-            type,
-            target,
-            config,
-            createdAt: Date.now(),
-            status: 'active',
-        };
-        const ops = this.operations.get(sessionId);
-        ops.push(op);
-        this.operationIndex.set(id, sessionId);
-        session.operationCount = ops.length;
-        this.evidenceBridge?.onOperation(op);
-        return op;
-    }
-    getSessionOperations(sessionId) {
-        return this.operations.get(sessionId) ?? [];
-    }
-    recordArtifact(operationId, data) {
-        const sessionId = this.operationIndex.get(operationId);
-        if (!sessionId)
-            throw new Error(`Operation "${operationId}" not found`);
-        const ops = this.operations.get(sessionId) ?? [];
-        const op = ops.find((o) => o.id === operationId);
-        if (!op)
-            throw new Error(`Operation "${operationId}" metadata missing`);
-        const artifact = {
-            operationId,
-            sessionId,
-            type: op.type,
-            timestamp: Date.now(),
-            data,
-        };
-        const sessionArtifacts = this.artifacts.get(sessionId);
-        sessionArtifacts.push(artifact);
-        const session = this.sessions.get(sessionId);
-        session.artifactCount = sessionArtifacts.length;
-        this.evidenceBridge?.onArtifact(artifact);
-        return artifact;
-    }
-    getArtifacts(sessionId, type) {
-        const all = this.artifacts.get(sessionId) ?? [];
-        if (!type)
-            return all;
-        return all.filter((a) => a.type === type);
-    }
-    getSessionSnapshot(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            return undefined;
-        }
-        return {
-            session,
-            stats: this.getSessionStats(sessionId),
-            operations: [...this.getSessionOperations(sessionId)],
-            artifacts: [...this.getArtifacts(sessionId)],
-        };
-    }
-    listSessionSnapshots() {
-        return this.listSessions().map((session) => ({
-            session,
-            stats: this.getSessionStats(session.id),
-            operations: [...this.getSessionOperations(session.id)],
-            artifacts: [...this.getArtifacts(session.id)],
-        }));
-    }
-    async applyHookPreset(sessionId, presetInvoker, args) {
-        const presetNames = getStringArray(args['presets']);
-        const singlePreset = typeof args['preset'] === 'string' ? args['preset'] : undefined;
-        const target = singlePreset ?? (presetNames.length > 0 ? presetNames.join(', ') : 'hook_preset');
-        return this.executeTrackedTool({
-            sessionId,
-            type: InstrumentationType.RUNTIME_HOOK,
-            target,
-            config: { ...args },
-            invoke: () => presetInvoker.handleHookPreset(args),
-            isSuccessful: (payload) => {
-                const injected = getStringArray(payload.injected);
-                return injected.length > 0;
-            },
-            buildArtifacts: (payload) => {
-                const injected = getStringArray(payload.injected);
-                const failed = Array.isArray(payload.failed)
-                    ? payload.failed.filter((item) => isRecord(item) &&
-                        typeof item['preset'] === 'string' &&
-                        typeof item['error'] === 'string')
-                    : [];
-                const method = payload.method === 'evaluateOnNewDocument' ? 'before-load' : 'runtime';
-                return [
-                    {
-                        presetIds: injected,
-                        failedPresets: failed,
-                        injectionPoint: method,
-                        scriptContent: injected.join(', '),
-                        body: payload,
-                    },
-                ];
-            },
-        });
-    }
-    async replayNetworkRequest(sessionId, replayInvoker, args) {
-        const requestId = typeof args['requestId'] === 'string' ? args['requestId'] : 'network_replay';
-        const urlOverride = typeof args['urlOverride'] === 'string' ? args['urlOverride'] : undefined;
-        return this.executeTrackedTool({
-            sessionId,
-            type: InstrumentationType.NETWORK_INTERCEPT,
-            target: requestId,
-            config: { ...args },
-            invoke: () => replayInvoker.handleNetworkReplayRequest(args),
-            buildArtifacts: (payload) => {
-                if (payload.dryRun === true && isRecord(payload.preview)) {
-                    return [
-                        {
-                            requestId,
-                            url: typeof payload.preview['url'] === 'string' ? payload.preview['url'] : urlOverride,
-                            method: typeof payload.preview['method'] === 'string'
-                                ? payload.preview['method']
-                                : undefined,
-                            headers: isRecord(payload.preview['headers'])
-                                ? payload.preview['headers']
-                                : undefined,
-                            body: payload.preview['body'],
-                            replayMode: 'dry-run',
-                        },
-                    ];
-                }
-                return [
-                    {
-                        requestId: typeof payload.requestId === 'string' ? payload.requestId : requestId,
-                        url: urlOverride,
-                        method: typeof args['methodOverride'] === 'string'
-                            ? args['methodOverride']
-                            : undefined,
-                        headers: isRecord(payload.headers)
-                            ? payload.headers
-                            : undefined,
-                        body: payload.body,
-                        statusCode: typeof payload.status === 'number' ? payload.status : undefined,
-                        statusText: typeof payload.statusText === 'string' ? payload.statusText : undefined,
-                        bodyTruncated: typeof payload.bodyTruncated === 'boolean' ? payload.bodyTruncated : undefined,
-                        replayMode: 'live',
-                    },
-                ];
-            },
-        });
-    }
-    getSessionStats(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return { operationCount: 0, artifactCount: 0 };
-        return {
-            operationCount: session.operationCount,
-            artifactCount: session.artifactCount,
-        };
-    }
-    findOperation(operationId) {
-        const sessionId = this.operationIndex.get(operationId);
-        if (!sessionId) {
-            return undefined;
-        }
-        return (this.operations.get(sessionId) ?? []).find((operation) => operation.id === operationId);
-    }
-    setOperationStatus(operationId, status) {
-        const operation = this.findOperation(operationId);
-        if (operation) {
-            operation.status = status;
-        }
-    }
-    async executeTrackedTool(spec) {
-        const operation = this.registerOperation(spec.sessionId, spec.type, spec.target, spec.config);
-        try {
-            const payload = parseToolPayload(await spec.invoke());
-            const isSuccessful = spec.isSuccessful
-                ? spec.isSuccessful(payload)
-                : payload['success'] !== false;
-            if (!isSuccessful) {
-                this.setOperationStatus(operation.id, 'failed');
-                return { operation, artifacts: [], payload };
-            }
-            const artifacts = (spec.buildArtifacts?.(payload) ?? []).map((artifactData) => this.recordArtifact(operation.id, artifactData));
-            this.setOperationStatus(operation.id, 'completed');
-            return { operation, artifacts, payload };
-        }
-        catch (error) {
-            this.setOperationStatus(operation.id, 'failed');
-            throw error;
-        }
-    }
-}

package/dist/src/server/instrumentation/index.d.ts

@@ -1,2 +0,0 @@
-export { InstrumentationSessionManager } from './InstrumentationSession.js';
-export { InstrumentationType, type InstrumentationArtifact, type InstrumentationArtifactData, type InstrumentationOperation, type SessionInfo, } from './types.js';

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

@@ -1,2 +0,0 @@
-export { InstrumentationSessionManager } from './InstrumentationSession.js';
-export { InstrumentationType, } from './types.js';

package/dist/src/server/instrumentation/types.d.ts

@@ -1,62 +0,0 @@
-export declare enum InstrumentationType {
-    BEFORE_LOAD_INJECT = "before-load-inject",
-    RUNTIME_HOOK = "runtime-hook",
-    NETWORK_INTERCEPT = "network-intercept",
-    FUNCTION_TRACE = "function-trace"
-}
-export interface InstrumentationOperation {
-    readonly id: string;
-    readonly sessionId: string;
-    readonly type: InstrumentationType;
-    readonly target: string;
-    readonly config: Record<string, unknown>;
-    readonly createdAt: number;
-    status: 'active' | 'paused' | 'completed' | 'failed';
-}
-export interface InstrumentationArtifact {
-    readonly operationId: string;
-    readonly sessionId: string;
-    readonly type: InstrumentationType;
-    readonly timestamp: number;
-    readonly data: InstrumentationArtifactData;
-}
-export interface InstrumentationArtifactData {
-    args?: unknown[];
-    returnValue?: unknown;
-    callStack?: string;
-    presetIds?: string[];
-    failedPresets?: Array<{
-        preset: string;
-        error: string;
-    }>;
-    url?: string;
-    method?: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-    requestId?: string;
-    statusCode?: number;
-    statusText?: string;
-    bodyTruncated?: boolean;
-    replayMode?: 'dry-run' | 'live';
-    functionName?: string;
-    executionTimeMs?: number;
-    scriptContent?: string;
-    injectionPoint?: 'before-load' | 'runtime';
-}
-export interface SessionInfo {
-    readonly id: string;
-    readonly name?: string;
-    readonly createdAt: number;
-    operationCount: number;
-    artifactCount: number;
-    status: 'active' | 'destroyed';
-}
-export interface InstrumentationSessionSnapshot {
-    session: SessionInfo;
-    stats: {
-        operationCount: number;
-        artifactCount: number;
-    };
-    operations: InstrumentationOperation[];
-    artifacts: InstrumentationArtifact[];
-}

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

@@ -1,7 +0,0 @@
-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

@@ -1,23 +0,0 @@
-import type { MacroDefinition } from './types.js';
-interface MacroJsonSchema {
-    id: string;
-    displayName: string;
-    description?: string;
-    tags?: string[];
-    timeoutMs?: number;
-    steps: Array<{
-        id: string;
-        toolName: string;
-        input?: Record<string, unknown>;
-        inputFrom?: Record<string, string>;
-        timeoutMs?: number;
-        optional?: boolean;
-    }>;
-}
-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,73 +0,0 @@
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, resolve } from 'node:path';
-import { logger } from '../../utils/logger.js';
-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 {
-            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}`);
-            }
-            else {
-                logger.warn(`[macros] Skipping ${file}: invalid macro schema`);
-            }
-        }
-        catch (err) {
-            logger.warn(`[macros] Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    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;
-        const s = step;
-        if (typeof s.id !== 'string' || !s.id)
-            return false;
-        if (typeof s.toolName !== 'string' || !s.toolName)
-            return false;
-    }
-    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.d.ts

@@ -1,12 +0,0 @@
-import { type WorkflowContract } from '../workflows/WorkflowContract.js';
-import type { MCPServerContext } from '../MCPServer.context.js';
-import type { MacroDefinition, MacroResult } from '../macros/types.js';
-export declare class MacroRunner {
-    private readonly ctx;
-    constructor(ctx: MCPServerContext);
-    buildWorkflowFromDefinition(def: MacroDefinition): WorkflowContract;
-    execute(def: MacroDefinition, inputOverrides?: Record<string, Record<string, unknown>>): Promise<MacroResult>;
-    formatProgressReport(result: MacroResult): string;
-    private _buildProgress;
-    private _buildPartialProgress;
-}

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

@@ -1,122 +0,0 @@
-import { createWorkflow, SequenceNodeBuilder, ToolNodeBuilder, } from '../workflows/WorkflowContract.js';
-import { executeExtensionWorkflow } from '../workflows/WorkflowEngine.js';
-export class MacroRunner {
-    ctx;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    buildWorkflowFromDefinition(def) {
-        return createWorkflow(def.id, def.displayName)
-            .description(def.description)
-            .tags(def.tags)
-            .timeoutMs(def.timeoutMs ?? 120_000)
-            .buildGraph(() => {
-            const seq = new SequenceNodeBuilder(`${def.id}-root`);
-            for (const step of def.steps) {
-                const toolBuilder = new ToolNodeBuilder(step.id, step.toolName)
-                    .input(step.input ?? {})
-                    .timeout(step.timeoutMs ?? 0);
-                if (step.inputFrom) {
-                    toolBuilder.inputFrom(step.inputFrom);
-                }
-                seq.step(toolBuilder);
-            }
-            return seq;
-        })
-            .onStart((ctx) => {
-            ctx.emitSpan('macro.start', {
-                macroId: def.id,
-                totalSteps: def.steps.length,
-            });
-        })
-            .onError((_ctx, err) => {
-            _ctx.emitSpan('macro.error', {
-                macroId: def.id,
-                error: err.message,
-            });
-        })
-            .build();
-    }
-    async execute(def, inputOverrides) {
-        const workflow = this.buildWorkflowFromDefinition(def);
-        const startMs = Date.now();
-        try {
-            const result = await executeExtensionWorkflow(this.ctx, workflow, {
-                nodeInputOverrides: inputOverrides,
-            });
-            const progress = this._buildProgress(def, result.spans, result.stepResults);
-            return {
-                macroId: def.id,
-                displayName: def.displayName,
-                ok: true,
-                durationMs: result.durationMs,
-                stepsCompleted: def.steps.length,
-                totalSteps: def.steps.length,
-                stepResults: result.stepResults,
-                progress,
-            };
-        }
-        catch (err) {
-            const durationMs = Date.now() - startMs;
-            const error = err instanceof Error ? err.message : String(err);
-            const progress = this._buildPartialProgress(def, error);
-            return {
-                macroId: def.id,
-                displayName: def.displayName,
-                ok: false,
-                durationMs,
-                stepsCompleted: progress.filter((p) => p.status === 'complete').length,
-                totalSteps: def.steps.length,
-                stepResults: {},
-                progress,
-                error,
-            };
-        }
-    }
-    formatProgressReport(result) {
-        const lines = [];
-        lines.push(`**Macro:** ${result.displayName} (\`${result.macroId}\`)`);
-        lines.push('');
-        for (const p of result.progress) {
-            const durStr = p.durationMs !== undefined ? ` (${p.durationMs}ms)` : '';
-            const errStr = p.error ? `: ${p.error}` : '';
-            const icon = p.status === 'complete' ? '✓' : p.status === 'failed' ? '✗' : '○';
-            lines.push(`[stage ${p.step}/${p.totalSteps}] ${icon} ${p.stepName} — ${p.status}${durStr}${errStr}`);
-        }
-        lines.push('');
-        if (result.ok) {
-            lines.push(`✓ Macro complete (${result.stepsCompleted}/${result.totalSteps} steps, ${result.durationMs}ms)`);
-        }
-        else {
-            lines.push(`✗ Macro failed at step ${result.stepsCompleted + 1}/${result.totalSteps}: ${result.error ?? 'unknown error'}`);
-        }
-        return lines.join('\n');
-    }
-    _buildProgress(def, spans, stepResults) {
-        return def.steps.map((step, i) => {
-            const startSpan = spans.find((s) => s.name === 'workflow.node.start' && s.attrs?.nodeId === step.id);
-            const finishSpan = spans.find((s) => s.name === 'workflow.node.finish' && s.attrs?.nodeId === step.id);
-            let durationMs;
-            if (startSpan && finishSpan) {
-                durationMs = new Date(finishSpan.at).getTime() - new Date(startSpan.at).getTime();
-            }
-            const hasResult = step.id in stepResults;
-            return {
-                step: i + 1,
-                totalSteps: def.steps.length,
-                stepName: step.id,
-                status: hasResult ? 'complete' : 'skipped',
-                durationMs,
-            };
-        });
-    }
-    _buildPartialProgress(def, error) {
-        return def.steps.map((step, i) => ({
-            step: i + 1,
-            totalSteps: def.steps.length,
-            stepName: step.id,
-            status: 'failed',
-            error: i === 0 ? error : undefined,
-        }));
-    }
-}

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

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

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

@@ -1,51 +0,0 @@
-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/macros/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types.js';
-export { MacroRunner } from './MacroRunner.js';
-export { MacroConfigLoader } from './MacroConfigLoader.js';

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

@@ -1,3 +0,0 @@
-export * from './types.js';
-export { MacroRunner } from './MacroRunner.js';
-export { MacroConfigLoader } from './MacroConfigLoader.js';

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

@@ -1,36 +0,0 @@
-export interface MacroStepProgress {
-    step: number;
-    totalSteps: number;
-    stepName: string;
-    status: 'running' | 'complete' | 'failed' | 'skipped';
-    durationMs?: number;
-    error?: string;
-}
-export interface MacroResult {
-    macroId: string;
-    displayName: string;
-    ok: boolean;
-    durationMs: number;
-    stepsCompleted: number;
-    totalSteps: number;
-    stepResults: Record<string, unknown>;
-    progress: MacroStepProgress[];
-    error?: string;
-    partialOutput?: unknown;
-}
-export interface MacroDefinition {
-    id: string;
-    displayName: string;
-    description: string;
-    tags: string[];
-    timeoutMs?: number;
-    steps: MacroStepDefinition[];
-}
-export interface MacroStepDefinition {
-    id: string;
-    toolName: string;
-    input?: Record<string, unknown>;
-    inputFrom?: Record<string, string>;
-    timeoutMs?: number;
-    optional?: boolean;
-}