@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/server/http/SseStream.js

@@ -0,0 +1,129 @@
+import { logger } from '../../utils/logger.js';
+export class SseStream {
+    eventBus;
+    options;
+    res = null;
+    heartbeatTimer = null;
+    unsubscribe = null;
+    closed = false;
+    constructor(eventBus, options = {}) {
+        this.eventBus = eventBus;
+        this.options = {
+            heartbeatMs: options.heartbeatMs ?? 30_000,
+            sessionId: options.sessionId,
+        };
+    }
+    start(res) {
+        if (this.res) {
+            logger.warn('SseStream already started');
+            return;
+        }
+        this.res = res;
+        this.closed = false;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        this.sendEvent('connected', {
+            timestamp: new Date().toISOString(),
+            sessionId: this.options.sessionId,
+        });
+        this.unsubscribe = this.eventBus.on('task:update', (payload) => {
+            const p = payload;
+            if (this.options.sessionId && p.sessionId !== this.options.sessionId) {
+                return;
+            }
+            this.sendEvent('task:update', payload);
+        });
+        this.startHeartbeat();
+        res.on('close', () => {
+            this.close();
+        });
+        res.on('error', (err) => {
+            logger.warn('SSE stream error:', err);
+            this.close();
+        });
+    }
+    sendEvent(event, data) {
+        if (!this.res || this.closed) {
+            return;
+        }
+        const eventData = JSON.stringify(data);
+        const lines = `event: ${event}\ndata: ${eventData}\n\n`;
+        try {
+            this.res.write(lines);
+        }
+        catch (err) {
+            logger.warn('Failed to write SSE event:', err);
+            this.close();
+        }
+    }
+    sendRaw(message) {
+        if (!this.res || this.closed) {
+            return;
+        }
+        try {
+            this.res.write(`${message}\n\n`);
+        }
+        catch (err) {
+            logger.warn('Failed to write SSE message:', err);
+            this.close();
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        if (this.res && !this.res.writableEnded) {
+            try {
+                this.res.end();
+            }
+            catch {
+            }
+        }
+        this.res = null;
+        logger.debug('SSE stream closed');
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.closed && this.res) {
+                try {
+                    this.res.write(`: heartbeat\n\n`);
+                }
+                catch {
+                    this.close();
+                }
+            }
+        }, this.options.heartbeatMs);
+    }
+}
+export function createProgressHandler(eventBus) {
+    return (req, res, sessionId) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method !== 'GET') {
+            res.writeHead(405, { 'Content-Type': 'text/plain' });
+            res.end('Method Not Allowed');
+            return;
+        }
+        const stream = new SseStream(eventBus, { sessionId });
+        stream.start(res);
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { ReverseEvidenceGraph } from '../evidence/ReverseEvidenceGraph.js';
+import type { InstrumentationOperation, InstrumentationArtifact } from './types.js';
+export declare class EvidenceGraphBridge {
+    private readonly graph;
+    private readonly operationNodeMap;
+    private readonly requestNodeMap;
+    constructor(graph: ReverseEvidenceGraph);
+    private getString;
+    private getInitiatorLabel;
+    linkRequestToInitiator(requestNodeId: string, initiatorStackNodeId: string): void;
+    onOperation(op: InstrumentationOperation): string | null;
+    onArtifact(artifact: InstrumentationArtifact): void;
+}

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

@@ -0,0 +1,150 @@
+export class EvidenceGraphBridge {
+    graph;
+    operationNodeMap = new Map();
+    requestNodeMap = new Map();
+    constructor(graph) {
+        this.graph = graph;
+    }
+    getString(value) {
+        return typeof value === 'string' && value.length > 0 ? value : undefined;
+    }
+    getInitiatorLabel(config) {
+        const directInitiator = this.getString(config.initiator);
+        if (directInitiator)
+            return directInitiator;
+        const directStack = this.getString(config.initiatorStack);
+        if (directStack)
+            return directStack;
+        const initiator = config.initiator;
+        if (initiator && typeof initiator === 'object') {
+            const record = initiator;
+            return (this.getString(record.stack) ??
+                this.getString(record.url) ??
+                this.getString(record.type) ??
+                this.getString(record.name));
+        }
+        return undefined;
+    }
+    linkRequestToInitiator(requestNodeId, initiatorStackNodeId) {
+        this.graph.addEdge(requestNodeId, initiatorStackNodeId, 'initiates');
+    }
+    onOperation(op) {
+        let primaryNodeId = null;
+        switch (op.type) {
+            case 'runtime-hook': {
+                const funcNode = this.graph.addNode('function', op.target, {
+                    functionName: op.target,
+                    sessionId: op.sessionId,
+                    operationId: op.id,
+                });
+                const scriptId = this.getString(op.config.scriptId);
+                if (scriptId) {
+                    const scriptNode = this.graph.addNode('script', `script:${scriptId}`, {
+                        scriptId,
+                        sessionId: op.sessionId,
+                        operationId: op.id,
+                    });
+                    this.graph.addEdge(scriptNode.id, funcNode.id, 'contains');
+                }
+                const hookNode = this.graph.addNode('breakpoint-hook', `hook:${op.target}`, {
+                    hookType: 'runtime-hook',
+                    sessionId: op.sessionId,
+                    operationId: op.id,
+                    config: op.config,
+                });
+                this.graph.addEdge(funcNode.id, hookNode.id, 'triggers');
+                primaryNodeId = hookNode.id;
+                break;
+            }
+            case 'network-intercept': {
+                const reqNode = this.graph.addNode('request', op.target, {
+                    url: op.target,
+                    sessionId: op.sessionId,
+                    operationId: op.id,
+                    config: op.config,
+                });
+                this.requestNodeMap.set(op.id, reqNode.id);
+                const initiatorLabel = this.getInitiatorLabel(op.config);
+                let initiatorNodeId = null;
+                if (initiatorLabel) {
+                    const initiatorNode = this.graph.addNode('initiator-stack', initiatorLabel, {
+                        sessionId: op.sessionId,
+                        operationId: op.id,
+                        initiator: op.config.initiator,
+                        initiatorStack: op.config.initiatorStack,
+                    });
+                    this.linkRequestToInitiator(reqNode.id, initiatorNode.id);
+                    initiatorNodeId = initiatorNode.id;
+                }
+                const initiatorScriptId = this.getString(op.config.initiatorScriptId);
+                if (initiatorNodeId && initiatorScriptId) {
+                    const scriptNode = this.graph.addNode('script', `script:${initiatorScriptId}`, {
+                        scriptId: initiatorScriptId,
+                        sessionId: op.sessionId,
+                        operationId: op.id,
+                    });
+                    this.graph.addEdge(initiatorNodeId, scriptNode.id, 'loads');
+                }
+                primaryNodeId = reqNode.id;
+                break;
+            }
+            case 'function-trace': {
+                const funcNode = this.graph.addNode('function', op.target, {
+                    functionName: op.target,
+                    sessionId: op.sessionId,
+                    operationId: op.id,
+                    traceMode: true,
+                });
+                const scriptId = this.getString(op.config.scriptId);
+                if (scriptId) {
+                    const scriptNode = this.graph.addNode('script', `script:${scriptId}`, {
+                        scriptId,
+                        sessionId: op.sessionId,
+                        operationId: op.id,
+                    });
+                    this.graph.addEdge(scriptNode.id, funcNode.id, 'contains');
+                }
+                primaryNodeId = funcNode.id;
+                break;
+            }
+            case 'before-load-inject': {
+                const scriptNode = this.graph.addNode('script', op.target, {
+                    injectionPoint: 'before-load',
+                    sessionId: op.sessionId,
+                    operationId: op.id,
+                });
+                primaryNodeId = scriptNode.id;
+                break;
+            }
+        }
+        if (primaryNodeId) {
+            this.operationNodeMap.set(op.id, primaryNodeId);
+        }
+        return primaryNodeId;
+    }
+    onArtifact(artifact) {
+        const operationNodeId = this.operationNodeMap.get(artifact.operationId);
+        const dataNode = this.graph.addNode('captured-data', `data:${artifact.operationId}`, {
+            sessionId: artifact.sessionId,
+            operationId: artifact.operationId,
+            artifactType: artifact.type,
+            ...artifact.data,
+        });
+        if (operationNodeId) {
+            this.graph.addEdge(operationNodeId, dataNode.id, 'captures');
+        }
+        if (artifact.data.replayMode === 'live') {
+            const replayNode = this.graph.addNode('replay-artifact', `replay:${artifact.operationId}`, {
+                sessionId: artifact.sessionId,
+                operationId: artifact.operationId,
+                artifactType: artifact.type,
+                replayMode: artifact.data.replayMode,
+                requestId: artifact.data.requestId,
+                url: artifact.data.url,
+                method: artifact.data.method,
+                statusCode: artifact.data.statusCode,
+            });
+            this.graph.addEdge(dataNode.id, replayNode.id, 'replays');
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+import type { InstrumentationArtifact, InstrumentationArtifactData, InstrumentationOperation, InstrumentationSessionSnapshot, SessionInfo } from './types.js';
+import { InstrumentationType } from './types.js';
+import type { EvidenceGraphBridge } from './EvidenceGraphBridge.js';
+import type { ToolResponse } from '../types.js';
+interface HookPresetInvoker {
+    handleHookPreset(args: Record<string, unknown>): Promise<ToolResponse>;
+}
+interface NetworkReplayInvoker {
+    handleNetworkReplayRequest(args: Record<string, unknown>): Promise<ToolResponse>;
+}
+interface TrackedToolExecutionResult<TPayload extends Record<string, unknown>> {
+    operation: InstrumentationOperation;
+    artifacts: InstrumentationArtifact[];
+    payload: TPayload;
+}
+export declare class InstrumentationSessionManager {
+    private readonly sessions;
+    private readonly operations;
+    private readonly artifacts;
+    private readonly operationIndex;
+    private evidenceBridge?;
+    setEvidenceBridge(bridge: EvidenceGraphBridge): void;
+    createSession(name?: string): SessionInfo;
+    destroySession(sessionId: string): void;
+    listSessions(): SessionInfo[];
+    getSession(sessionId: string): SessionInfo | undefined;
+    registerOperation(sessionId: string, type: InstrumentationType, target: string, config: Record<string, unknown>): InstrumentationOperation;
+    getSessionOperations(sessionId: string): InstrumentationOperation[];
+    recordArtifact(operationId: string, data: InstrumentationArtifactData): InstrumentationArtifact;
+    getArtifacts(sessionId: string, type?: InstrumentationType): InstrumentationArtifact[];
+    getSessionSnapshot(sessionId: string): InstrumentationSessionSnapshot | undefined;
+    listSessionSnapshots(): InstrumentationSessionSnapshot[];
+    applyHookPreset(sessionId: string, presetInvoker: HookPresetInvoker, args: Record<string, unknown>): Promise<TrackedToolExecutionResult<{
+        success?: boolean;
+        injected?: unknown;
+        failed?: unknown;
+        method?: unknown;
+        [key: string]: unknown;
+    }>>;
+    replayNetworkRequest(sessionId: string, replayInvoker: NetworkReplayInvoker, args: Record<string, unknown>): Promise<TrackedToolExecutionResult<{
+        success?: boolean;
+        dryRun?: unknown;
+        preview?: unknown;
+        status?: unknown;
+        statusText?: unknown;
+        headers?: unknown;
+        body?: unknown;
+        bodyTruncated?: unknown;
+        requestId?: unknown;
+        [key: string]: unknown;
+    }>>;
+    getSessionStats(sessionId: string): {
+        operationCount: number;
+        artifactCount: number;
+    };
+    private findOperation;
+    private setOperationStatus;
+    private executeTrackedTool;
+}
+export {};

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

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

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

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

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

@@ -0,0 +1,62 @@
+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[];
+}