@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/server/extensions/plugin-env.js

@@ -1,21 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import dotenv from 'dotenv';
-const loadedEnvPaths = new Set();
-function toManifestUrl(manifestLocation) {
-    return manifestLocation.startsWith('file:')
-        ? new URL(manifestLocation)
-        : pathToFileURL(manifestLocation);
-}
-export function loadPluginEnv(manifestLocation) {
-    const pluginDirUrl = new URL('.', toManifestUrl(manifestLocation));
-    const pluginDir = fileURLToPath(pluginDirUrl);
-    const envPath = join(pluginDir, '.env');
-    if (loadedEnvPaths.has(envPath))
-        return;
-    if (existsSync(envPath)) {
-        dotenv.config({ path: envPath, override: false });
-    }
-    loadedEnvPaths.add(envPath);
-}

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

@@ -1,80 +0,0 @@
-import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { ExtensionBuilder, PluginLifecycleContext, PluginState } from '../plugins/PluginContract.js';
-import type { WorkflowContract } from '../workflows/WorkflowContract.js';
-export declare const INSTALLED_EXTENSION_METADATA_FILENAME = ".jshook-install.json";
-export interface InstalledExtensionMetadata {
-    version: 1;
-    kind: 'plugin' | 'workflow';
-    slug: string;
-    id: string;
-    source: {
-        type: string;
-        repo: string;
-        ref: string;
-        commit: string;
-        subpath: string;
-        entry: string;
-    };
-}
-export interface ExtensionToolRecord {
-    name: string;
-    domain: string;
-    source: string;
-    tool: Tool;
-    registeredTool?: RegisteredTool;
-    boostTier?: string;
-    handler?: Function;
-}
-export interface ExtensionPluginRecord {
-    id: string;
-    name: string;
-    source: string;
-    author?: string;
-    sourceRepo?: string;
-    domains: string[];
-    workflows: string[];
-    tools: string[];
-}
-export interface ExtensionPluginRuntimeRecord {
-    plugin: ExtensionBuilder;
-    lifecycleContext: PluginLifecycleContext;
-    state: PluginState;
-    source: string;
-}
-export interface ExtensionWorkflowRuntimeRecord {
-    workflow: WorkflowContract;
-    source: string;
-    route?: WorkflowContract['route'];
-}
-export interface ExtensionWorkflowRecord {
-    id: string;
-    displayName: string;
-    source: string;
-    description?: string;
-    tags?: string[];
-    timeoutMs?: number;
-    defaultMaxConcurrency?: number;
-    route?: WorkflowContract['route'];
-}
-export interface ExtensionListResult {
-    pluginRoots: string[];
-    workflowRoots: string[];
-    pluginCount: number;
-    workflowCount: number;
-    toolCount: number;
-    lastReloadAt?: string;
-    plugins: ExtensionPluginRecord[];
-    workflows: ExtensionWorkflowRecord[];
-    tools: Array<{
-        name: string;
-        domain: string;
-        source: string;
-    }>;
-}
-export interface ExtensionReloadResult extends ExtensionListResult {
-    addedTools: number;
-    removedTools: number;
-    errors: string[];
-    warnings: string[];
-}

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

@@ -1 +0,0 @@
-export const INSTALLED_EXTENSION_METADATA_FILENAME = '.jshook-install.json';

package/dist/src/server/http/HttpMiddleware.d.ts

@@ -1,5 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare function checkOrigin(req: IncomingMessage, res: ServerResponse): boolean;
-export declare function checkAuth(req: IncomingMessage, res: ServerResponse): boolean;
-export declare function readBodyWithLimit(req: IncomingMessage, res: ServerResponse, maxBytes?: number): Promise<unknown>;
-export declare function checkRateLimit(req: IncomingMessage, res: ServerResponse, authenticated?: boolean): boolean;

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

@@ -1,175 +0,0 @@
-import { timingSafeEqual as cryptoTimingSafeEqual } from 'node:crypto';
-const LOCALHOST_ORIGINS = new Set(['http://127.0.0.1', 'http://localhost', 'http://[::1]']);
-export function checkOrigin(req, res) {
-    const origin = req.headers.origin;
-    if (!origin)
-        return true;
-    let originBase;
-    try {
-        const parsed = new URL(origin);
-        originBase = `${parsed.protocol}//${parsed.hostname}`;
-    }
-    catch {
-        res.writeHead(403, { 'Content-Type': 'text/plain' });
-        res.end('Forbidden – invalid Origin header');
-        return false;
-    }
-    if (LOCALHOST_ORIGINS.has(originBase))
-        return true;
-    if (process.env.MCP_AUTH_TOKEN)
-        return true;
-    res.writeHead(403, { 'Content-Type': 'text/plain' });
-    res.end('Forbidden – cross-origin requests require MCP_AUTH_TOKEN');
-    return false;
-}
-export function checkAuth(req, res) {
-    const expected = process.env.MCP_AUTH_TOKEN;
-    if (!expected) {
-        const host = process.env.MCP_HOST ?? '127.0.0.1';
-        const SAFE_LOCAL_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
-        const isLocal = SAFE_LOCAL_HOSTS.has(host);
-        if (!isLocal && !['1', 'true'].includes((process.env.MCP_ALLOW_INSECURE ?? '').toLowerCase())) {
-            res.writeHead(403, { 'Content-Type': 'text/plain' });
-            res.end('Forbidden – MCP_AUTH_TOKEN is required when binding to non-localhost. Set MCP_ALLOW_INSECURE=1 to override.');
-            return false;
-        }
-        return true;
-    }
-    const header = req.headers.authorization;
-    if (!header?.startsWith('Bearer ')) {
-        res.writeHead(401, { 'Content-Type': 'text/plain' });
-        res.end('Unauthorized – missing or malformed Authorization header');
-        return false;
-    }
-    const token = header.slice(7);
-    const tokenBuf = Buffer.from(token);
-    const expectedBuf = Buffer.from(expected);
-    if (tokenBuf.length !== expectedBuf.length || !cryptoTimingSafeEqual(tokenBuf, expectedBuf)) {
-        res.writeHead(403, { 'Content-Type': 'text/plain' });
-        res.end('Forbidden – invalid token');
-        return false;
-    }
-    return true;
-}
-const DEFAULT_MAX_BODY_BYTES = (() => {
-    const envVal = parseInt(process.env.MCP_MAX_BODY_BYTES ?? '', 10);
-    return Number.isFinite(envVal) && envVal > 0 ? envVal : 10 * 1024 * 1024;
-})();
-export function readBodyWithLimit(req, res, maxBytes = DEFAULT_MAX_BODY_BYTES) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let received = 0;
-        const declaredLength = parseInt(req.headers['content-length'] ?? '', 10);
-        if (!isNaN(declaredLength) && declaredLength > maxBytes) {
-            res.writeHead(413, { 'Content-Type': 'text/plain' });
-            res.end(`Payload Too Large – limit is ${maxBytes} bytes`);
-            reject(new Error('body_too_large'));
-            return;
-        }
-        let overflowed = false;
-        req.on('data', (chunk) => {
-            if (overflowed)
-                return;
-            received += chunk.length;
-            if (received > maxBytes) {
-                overflowed = true;
-                res.writeHead(413, { 'Content-Type': 'text/plain' });
-                res.end(`Payload Too Large – limit is ${maxBytes} bytes`, () => {
-                    req.destroy();
-                });
-                reject(new Error('body_too_large'));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', () => {
-            if (overflowed)
-                return;
-            try {
-                const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-                resolve(body);
-            }
-            catch {
-                res.writeHead(400, { 'Content-Type': 'text/plain' });
-                res.end('Bad Request – invalid JSON body');
-                reject(new Error('invalid_json'));
-            }
-        });
-        req.on('error', (err) => reject(err));
-    });
-}
-const RATE_LIMIT_WINDOW_MS = (() => {
-    const envVal = parseInt(process.env.MCP_RATE_LIMIT_WINDOW_MS ?? '', 10);
-    return Number.isFinite(envVal) && envVal > 0 ? envVal : 60_000;
-})();
-const RATE_LIMIT_MAX_REQUESTS = (() => {
-    const envVal = parseInt(process.env.MCP_RATE_LIMIT_MAX ?? '', 10);
-    return Number.isFinite(envVal) && envVal > 0 ? envVal : 60;
-})();
-const rateLimitStore = new Map();
-const RATE_LIMIT_MAX_IPS = 10_000;
-const CLEANUP_INTERVAL_MS = 5 * 60_000;
-let lastCleanup = Date.now();
-function rateLimitCleanup(now) {
-    if (now - lastCleanup < CLEANUP_INTERVAL_MS)
-        return;
-    lastCleanup = now;
-    const cutoff = now - RATE_LIMIT_WINDOW_MS;
-    for (const [ip, entry] of rateLimitStore) {
-        entry.timestamps = entry.timestamps.filter((t) => t > cutoff);
-        if (entry.timestamps.length === 0) {
-            rateLimitStore.delete(ip);
-        }
-    }
-}
-function rateLimitEvictIfNeeded() {
-    if (rateLimitStore.size <= RATE_LIMIT_MAX_IPS)
-        return;
-    const evictCount = Math.ceil(RATE_LIMIT_MAX_IPS * 0.1);
-    let removed = 0;
-    for (const key of rateLimitStore.keys()) {
-        if (removed >= evictCount)
-            break;
-        rateLimitStore.delete(key);
-        removed++;
-    }
-}
-function getClientIP(req) {
-    const trustProxy = ['1', 'true'].includes((process.env.MCP_TRUST_PROXY ?? '').toLowerCase());
-    if (trustProxy) {
-        const forwarded = req.headers['x-forwarded-for'];
-        if (forwarded) {
-            const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(',')[0];
-            return first.trim();
-        }
-    }
-    return req.socket.remoteAddress ?? 'unknown';
-}
-export function checkRateLimit(req, res, authenticated = false) {
-    if (['0', 'false'].includes((process.env.MCP_RATE_LIMIT_ENABLED ?? '').toLowerCase())) {
-        return true;
-    }
-    const maxRequests = authenticated ? RATE_LIMIT_MAX_REQUESTS * 3 : RATE_LIMIT_MAX_REQUESTS;
-    const now = Date.now();
-    rateLimitCleanup(now);
-    rateLimitEvictIfNeeded();
-    const ip = getClientIP(req);
-    let entry = rateLimitStore.get(ip);
-    if (!entry) {
-        entry = { timestamps: [] };
-        rateLimitStore.set(ip, entry);
-    }
-    const cutoff = now - RATE_LIMIT_WINDOW_MS;
-    entry.timestamps = entry.timestamps.filter((t) => t > cutoff);
-    if (entry.timestamps.length >= maxRequests) {
-        const retryAfterSec = Math.ceil(RATE_LIMIT_WINDOW_MS / 1000);
-        res.writeHead(429, {
-            'Content-Type': 'text/plain',
-            'Retry-After': String(retryAfterSec),
-        });
-        res.end(`Too Many Requests – limit is ${maxRequests} per ${retryAfterSec}s window`);
-        return false;
-    }
-    entry.timestamps.push(now);
-    return true;
-}

package/dist/src/server/http/SseStream.d.ts

@@ -1,21 +0,0 @@
-import type { ServerResponse, IncomingMessage } from 'node:http';
-import type { EventBus, ServerEventMap } from '../EventBus.js';
-export interface SseStreamOptions {
-    sessionId?: string;
-    heartbeatMs?: number;
-}
-export declare class SseStream {
-    private readonly eventBus;
-    private readonly options;
-    private res;
-    private heartbeatTimer;
-    private unsubscribe;
-    private closed;
-    constructor(eventBus: EventBus<ServerEventMap>, options?: SseStreamOptions);
-    start(res: ServerResponse): void;
-    sendEvent(event: string, data: unknown): void;
-    sendRaw(message: string): void;
-    close(): void;
-    private startHeartbeat;
-}
-export declare function createProgressHandler(eventBus: EventBus<ServerEventMap>): (req: IncomingMessage, res: ServerResponse, sessionId?: string) => void;

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

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

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

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

@@ -1,60 +0,0 @@
-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 {};