@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/debugger/DebuggerManager.impl.core.events.js

@@ -1,106 +0,0 @@
-import { logger } from '../../utils/logger.js';
-function asEventsCoreContext(ctx) {
-    return ctx;
-}
-export function onBreakpointHitCore(ctx, callback) {
-    const coreCtx = asEventsCoreContext(ctx);
-    coreCtx.breakpointHitCallbacks.add(callback);
-    logger.info('Breakpoint hit callback registered', {
-        totalCallbacks: coreCtx.breakpointHitCallbacks.size,
-    });
-}
-export function offBreakpointHitCore(ctx, callback) {
-    const coreCtx = asEventsCoreContext(ctx);
-    coreCtx.breakpointHitCallbacks.delete(callback);
-    logger.info('Breakpoint hit callback removed', {
-        totalCallbacks: coreCtx.breakpointHitCallbacks.size,
-    });
-}
-export function clearBreakpointHitCallbacksCore(ctx) {
-    const coreCtx = asEventsCoreContext(ctx);
-    coreCtx.breakpointHitCallbacks.clear();
-    logger.info('All breakpoint hit callbacks cleared');
-}
-export function getBreakpointHitCallbackCountCore(ctx) {
-    const coreCtx = asEventsCoreContext(ctx);
-    return coreCtx.breakpointHitCallbacks.size;
-}
-export async function handlePausedCore(ctx, params) {
-    const coreCtx = asEventsCoreContext(ctx);
-    const pausedState = {
-        callFrames: params.callFrames,
-        reason: params.reason,
-        data: params.data,
-        hitBreakpoints: params.hitBreakpoints,
-        timestamp: Date.now(),
-    };
-    coreCtx.pausedState = pausedState;
-    if (params.hitBreakpoints) {
-        for (const breakpointId of params.hitBreakpoints) {
-            const bp = coreCtx.breakpoints.get(breakpointId);
-            if (bp) {
-                bp.hitCount++;
-            }
-        }
-    }
-    logger.info('Execution paused', {
-        reason: params.reason,
-        location: params.callFrames[0]?.location,
-        hitBreakpoints: params.hitBreakpoints,
-    });
-    if (params.hitBreakpoints &&
-        params.hitBreakpoints.length > 0 &&
-        coreCtx.breakpointHitCallbacks.size > 0) {
-        const firstHitBreakpointId = params.hitBreakpoints[0];
-        const topFrame = params.callFrames[0];
-        let variables;
-        try {
-            const result = await coreCtx.getScopeVariables({ skipErrors: true });
-            variables = result.variables;
-        }
-        catch (error) {
-            logger.debug('Failed to auto-fetch variables for breakpoint hit callback:', error);
-        }
-        const event = {
-            breakpointId: firstHitBreakpointId,
-            breakpointInfo: coreCtx.breakpoints.get(firstHitBreakpointId),
-            location: {
-                scriptId: topFrame.location.scriptId,
-                lineNumber: topFrame.location.lineNumber,
-                columnNumber: topFrame.location.columnNumber,
-                url: topFrame.url,
-            },
-            callFrames: params.callFrames,
-            timestamp: Date.now(),
-            variables,
-            reason: params.reason,
-        };
-        for (const callback of coreCtx.breakpointHitCallbacks) {
-            try {
-                await Promise.resolve(callback(event));
-            }
-            catch (error) {
-                logger.error('Breakpoint hit callback error:', error);
-            }
-        }
-    }
-    for (const resolver of coreCtx.pausedResolvers) {
-        resolver(coreCtx.pausedState);
-    }
-    coreCtx.pausedResolvers = [];
-}
-export function handleResumedCore(ctx) {
-    const coreCtx = asEventsCoreContext(ctx);
-    coreCtx.pausedState = null;
-    logger.info('Execution resumed');
-}
-export function handleBreakpointResolvedCore(ctx, params) {
-    const coreCtx = asEventsCoreContext(ctx);
-    const bp = coreCtx.breakpoints.get(params.breakpointId);
-    if (bp) {
-        logger.info('Breakpoint resolved', {
-            breakpointId: params.breakpointId,
-            location: params.location,
-        });
-    }
-}

package/dist/src/modules/debugger/DebuggerManager.impl.core.execution.d.ts

@@ -1,22 +0,0 @@
-import type { PausedState } from '../debugger/DebuggerManager.impl.core.class.js';
-type PauseOnExceptionsState = 'none' | 'uncaught' | 'all';
-export interface EvaluateOnCallFrameValue {
-    value?: unknown;
-    [key: string]: unknown;
-}
-export declare function setPauseOnExceptionsCore(ctx: unknown, state: PauseOnExceptionsState): Promise<void>;
-export declare function getPauseOnExceptionsStateCore(ctx: unknown): PauseOnExceptionsState;
-export declare function pauseCore(ctx: unknown): Promise<void>;
-export declare function resumeCore(ctx: unknown): Promise<void>;
-export declare function stepIntoCore(ctx: unknown): Promise<void>;
-export declare function stepOverCore(ctx: unknown): Promise<void>;
-export declare function stepOutCore(ctx: unknown): Promise<void>;
-export declare function getPausedStateCore(ctx: unknown): PausedState | null;
-export declare function isPausedCore(ctx: unknown): boolean;
-export declare function waitForPausedCore(ctx: unknown, timeout?: number): Promise<PausedState>;
-export declare function evaluateOnCallFrameCore(ctx: unknown, params: {
-    callFrameId: string;
-    expression: string;
-    returnByValue?: boolean;
-}): Promise<EvaluateOnCallFrameValue>;
-export {};

package/dist/src/modules/debugger/DebuggerManager.impl.core.execution.js

@@ -1,155 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-function asExecutionCoreContext(ctx) {
-    return ctx;
-}
-export async function setPauseOnExceptionsCore(ctx, state) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.setPauseOnExceptions', { state });
-        coreCtx.pauseOnExceptionsState = state;
-        logger.info(`Pause on exceptions set to: ${state}`);
-    }
-    catch (error) {
-        logger.error('Failed to set pause on exceptions:', error);
-        throw error;
-    }
-}
-export function getPauseOnExceptionsStateCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    return coreCtx.pauseOnExceptionsState;
-}
-export async function pauseCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.pause');
-        logger.info('Execution paused');
-    }
-    catch (error) {
-        logger.error('Failed to pause execution:', error);
-        throw error;
-    }
-}
-export async function resumeCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.resume');
-        logger.info('Execution resumed');
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes('not paused') ||
-            msg.includes('cannot be resumed') ||
-            msg.includes('while paused')) {
-            logger.warn('Debugger resume skipped: not currently paused');
-            return;
-        }
-        logger.error('Failed to resume execution:', error);
-        throw error;
-    }
-}
-export async function stepIntoCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.stepInto');
-        logger.info('Step into');
-    }
-    catch (error) {
-        logger.error('Failed to step into:', error);
-        throw error;
-    }
-}
-export async function stepOverCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.stepOver');
-        logger.info('Step over');
-    }
-    catch (error) {
-        logger.error('Failed to step over:', error);
-        throw error;
-    }
-}
-export async function stepOutCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.stepOut');
-        logger.info('Step out');
-    }
-    catch (error) {
-        logger.error('Failed to step out:', error);
-        throw error;
-    }
-}
-export function getPausedStateCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    return coreCtx.pausedState;
-}
-export function isPausedCore(ctx) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    return coreCtx.pausedState !== null;
-}
-export async function waitForPausedCore(ctx, timeout = 30000) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger is not enabled. Call init() or enable() first.');
-    }
-    if (coreCtx.pausedState) {
-        return coreCtx.pausedState;
-    }
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            const index = coreCtx.pausedResolvers.indexOf(resolve);
-            if (index > -1) {
-                coreCtx.pausedResolvers.splice(index, 1);
-            }
-            reject(new Error('Timeout waiting for paused event'));
-        }, timeout);
-        coreCtx.pausedResolvers.push((state) => {
-            clearTimeout(timer);
-            resolve(state);
-        });
-    });
-}
-export async function evaluateOnCallFrameCore(ctx, params) {
-    const coreCtx = asExecutionCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled');
-    }
-    if (!coreCtx.pausedState) {
-        throw new PrerequisiteError('Not in paused state');
-    }
-    try {
-        const result = (await coreCtx.cdpSession.send('Debugger.evaluateOnCallFrame', {
-            callFrameId: params.callFrameId,
-            expression: params.expression,
-            returnByValue: params.returnByValue !== false,
-        }));
-        logger.info(`Evaluated on call frame: ${params.expression}`, {
-            result: result.result.value,
-        });
-        return result.result;
-    }
-    catch (error) {
-        logger.error('Failed to evaluate on call frame:', error);
-        throw error;
-    }
-}

package/dist/src/modules/debugger/DebuggerManager.impl.core.js

@@ -1 +0,0 @@
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.core.class.js';

package/dist/src/modules/debugger/DebuggerManager.impl.core.scope.d.ts

@@ -1,5 +0,0 @@
-import type { ScopeVariable, GetScopeVariablesOptions, GetScopeVariablesResult } from '../../types/index.js';
-import type { ObjectPropertyInfo } from '../debugger/DebuggerManager.impl.core.class.js';
-export declare function getScopeVariablesCore(ctx: unknown, options?: GetScopeVariablesOptions): Promise<GetScopeVariablesResult>;
-export declare function getObjectPropertiesByIdCore(ctx: unknown, objectId: string): Promise<ObjectPropertyInfo[]>;
-export declare function getObjectPropertiesCore(ctx: unknown, objectId: string, maxDepth: number): Promise<ScopeVariable[]>;

package/dist/src/modules/debugger/DebuggerManager.impl.core.scope.js

@@ -1,174 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-function asScopeCoreContext(ctx) {
-    return ctx;
-}
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export async function getScopeVariablesCore(ctx, options = {}) {
-    const coreCtx = asScopeCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger not enabled. Call init() or enable() first.');
-    }
-    if (!coreCtx.pausedState) {
-        throw new PrerequisiteError('Not in paused state. Use pause() or set a breakpoint first.');
-    }
-    const { callFrameId, includeObjectProperties = false, maxDepth = 1, skipErrors = true } = options;
-    try {
-        const targetFrame = callFrameId
-            ? coreCtx.pausedState.callFrames.find((f) => f.callFrameId === callFrameId)
-            : coreCtx.pausedState.callFrames[0];
-        if (!targetFrame) {
-            throw new Error(`Call frame not found: ${callFrameId || 'top frame'}`);
-        }
-        const variables = [];
-        const errors = [];
-        let successfulScopes = 0;
-        for (const scope of targetFrame.scopeChain) {
-            try {
-                if (scope.object.objectId) {
-                    const properties = (await coreCtx.cdpSession.send('Runtime.getProperties', {
-                        objectId: scope.object.objectId,
-                        ownProperties: true,
-                    }));
-                    for (const prop of properties.result) {
-                        if (prop.name === '__proto__')
-                            continue;
-                        const variable = {
-                            name: prop.name,
-                            value: prop.value?.value,
-                            type: prop.value?.type || 'unknown',
-                            scope: scope.type,
-                            writable: prop.writable,
-                            configurable: prop.configurable,
-                            enumerable: prop.enumerable,
-                            objectId: prop.value?.objectId,
-                        };
-                        variables.push(variable);
-                        if (includeObjectProperties && prop.value?.objectId && maxDepth > 0) {
-                            try {
-                                const nestedProps = await getObjectPropertiesCore(coreCtx, prop.value.objectId, maxDepth - 1);
-                                for (const nested of nestedProps) {
-                                    variables.push({
-                                        ...nested,
-                                        name: `${prop.name}.${nested.name}`,
-                                        scope: scope.type,
-                                    });
-                                }
-                            }
-                            catch (nestedError) {
-                                logger.debug(`Failed to get nested properties for ${prop.name}:`, nestedError);
-                            }
-                        }
-                    }
-                    successfulScopes++;
-                }
-            }
-            catch (error) {
-                const errorMsg = toErrorMessage(error);
-                logger.warn(`Failed to get properties for scope ${scope.type}:`, errorMsg);
-                errors.push({
-                    scope: scope.type,
-                    error: errorMsg,
-                });
-                if (!skipErrors) {
-                    throw error;
-                }
-            }
-        }
-        const result = {
-            success: true,
-            variables,
-            callFrameId: targetFrame.callFrameId,
-            callFrameInfo: {
-                functionName: targetFrame.functionName || '(anonymous)',
-                location: `${targetFrame.url}:${targetFrame.location.lineNumber}:${targetFrame.location.columnNumber}`,
-            },
-            totalScopes: targetFrame.scopeChain.length,
-            successfulScopes,
-        };
-        if (errors.length > 0) {
-            result.errors = errors;
-        }
-        logger.info(`Got ${variables.length} variables from ${successfulScopes}/${targetFrame.scopeChain.length} scopes`, {
-            callFrameId: targetFrame.callFrameId,
-            functionName: targetFrame.functionName,
-            errors: errors.length,
-        });
-        return result;
-    }
-    catch (error) {
-        logger.error('Failed to get scope variables:', error);
-        throw error;
-    }
-}
-export async function getObjectPropertiesByIdCore(ctx, objectId) {
-    const coreCtx = asScopeCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new Error('Debugger not enabled');
-    }
-    if (!objectId || typeof objectId !== 'string') {
-        throw new Error('objectId parameter is required');
-    }
-    try {
-        const properties = (await coreCtx.cdpSession.send('Runtime.getProperties', {
-            objectId,
-            ownProperties: true,
-            accessorPropertiesOnly: false,
-            generatePreview: true,
-        }));
-        const result = [];
-        for (const prop of properties.result) {
-            if (!prop.value) {
-                continue;
-            }
-            result.push({
-                name: prop.name,
-                value: prop.value.value ?? prop.value.description,
-                type: prop.value.type || 'unknown',
-                objectId: prop.value.objectId,
-                className: prop.value.className,
-                description: prop.value.description,
-            });
-        }
-        return result;
-    }
-    catch (error) {
-        const message = toErrorMessage(error);
-        if (message.includes('Could not find object with given id') ||
-            message.includes('Invalid remote object id')) {
-            throw new Error('Object handle is expired or invalid. Pause execution again and reacquire objectId from get_scope_variables_enhanced.', { cause: error });
-        }
-        throw error;
-    }
-}
-export async function getObjectPropertiesCore(ctx, objectId, maxDepth) {
-    const coreCtx = asScopeCoreContext(ctx);
-    if (maxDepth <= 0 || !coreCtx.cdpSession) {
-        return [];
-    }
-    try {
-        const properties = (await coreCtx.cdpSession.send('Runtime.getProperties', {
-            objectId,
-            ownProperties: true,
-        }));
-        const variables = [];
-        for (const prop of properties.result) {
-            if (prop.name === '__proto__')
-                continue;
-            variables.push({
-                name: prop.name,
-                value: prop.value?.value,
-                type: prop.value?.type || 'unknown',
-                scope: 'local',
-                objectId: prop.value?.objectId,
-            });
-        }
-        return variables;
-    }
-    catch (error) {
-        logger.debug(`Failed to get object properties for ${objectId}:`, error);
-        return [];
-    }
-}

package/dist/src/modules/debugger/DebuggerManager.impl.d.ts

@@ -1,2 +0,0 @@
-export type { BreakpointInfo, CallFrame, ObjectPropertyInfo, PausedState, Scope, } from '../debugger/DebuggerManager.impl.core.js';
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.core.js';

package/dist/src/modules/debugger/DebuggerManager.impl.js

@@ -1 +0,0 @@
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.core.js';

package/dist/src/modules/debugger/DebuggerManager.js

@@ -1 +0,0 @@
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.js';

package/dist/src/modules/debugger/DebuggerSessionManager.d.ts

@@ -1,22 +0,0 @@
-import type { DebuggerSession } from '../../types/index.js';
-import type { DebuggerManager } from '../debugger/DebuggerManager.js';
-type SavedDebuggerSessionSummary = {
-    path: string;
-    timestamp: number;
-    metadata?: DebuggerSession['metadata'];
-};
-export declare class DebuggerSessionManager {
-    private debuggerManager;
-    private readonly SESSION_IMPORT_BATCH_SIZE;
-    private readonly SESSION_FILE_READ_BATCH_SIZE;
-    constructor(debuggerManager: DebuggerManager);
-    private processInBatches;
-    private readSessionFile;
-    private validateFilePath;
-    exportSession(metadata?: DebuggerSession['metadata']): DebuggerSession;
-    saveSession(filePath?: string, metadata?: DebuggerSession['metadata']): Promise<string>;
-    loadSessionFromFile(filePath: string): Promise<void>;
-    importSession(sessionData: DebuggerSession | string): Promise<void>;
-    listSavedSessions(): Promise<SavedDebuggerSessionSummary[]>;
-}
-export {};

package/dist/src/modules/debugger/DebuggerSessionManager.js

@@ -1,176 +0,0 @@
-import * as fs from 'fs/promises';
-import * as os from 'os';
-import * as path from 'path';
-import { logger } from '../../utils/logger.js';
-export class DebuggerSessionManager {
-    debuggerManager;
-    SESSION_IMPORT_BATCH_SIZE = 8;
-    SESSION_FILE_READ_BATCH_SIZE = 8;
-    constructor(debuggerManager) {
-        this.debuggerManager = debuggerManager;
-    }
-    async processInBatches(items, batchSize, worker) {
-        for (let i = 0; i < items.length; i += batchSize) {
-            const batch = items.slice(i, i + batchSize);
-            await Promise.all(batch.map((item) => worker(item)));
-        }
-    }
-    async readSessionFile(filePath) {
-        return fs.readFile(filePath, 'utf-8');
-    }
-    async validateFilePath(filePath) {
-        const resolved = path.resolve(filePath);
-        const cwd = await fs.realpath(process.cwd());
-        const tmpDir = await fs.realpath(os.tmpdir());
-        const parentDir = path.dirname(resolved);
-        let realParent;
-        try {
-            realParent = await fs.realpath(parentDir);
-        }
-        catch {
-            realParent = parentDir;
-        }
-        const realPath = path.join(realParent, path.basename(resolved));
-        const inCwd = realPath === cwd || realPath.startsWith(cwd + path.sep);
-        const inTmp = realPath === tmpDir || realPath.startsWith(tmpDir + path.sep);
-        if (!inCwd && !inTmp) {
-            throw new Error('filePath must be within the current working directory or system temp dir.');
-        }
-        return realPath;
-    }
-    exportSession(metadata) {
-        const session = {
-            version: '1.0',
-            timestamp: Date.now(),
-            breakpoints: Array.from(this.debuggerManager.getBreakpoints().values()).map((bp) => ({
-                location: {
-                    scriptId: bp.location.scriptId,
-                    url: bp.location.url,
-                    lineNumber: bp.location.lineNumber,
-                    columnNumber: bp.location.columnNumber,
-                },
-                condition: bp.condition,
-                enabled: bp.enabled,
-            })),
-            pauseOnExceptions: this.debuggerManager.getPauseOnExceptionsState(),
-            metadata: metadata || {},
-        };
-        logger.info('Session exported', {
-            breakpointCount: session.breakpoints.length,
-            pauseOnExceptions: session.pauseOnExceptions,
-        });
-        return session;
-    }
-    async saveSession(filePath, metadata) {
-        const session = this.exportSession(metadata);
-        if (!filePath) {
-            const sessionsDir = path.join(process.cwd(), 'debugger-sessions');
-            await fs.mkdir(sessionsDir, { recursive: true });
-            filePath = path.join(sessionsDir, `session-${Date.now()}.json`);
-        }
-        else {
-            filePath = await this.validateFilePath(filePath);
-            const dir = path.dirname(filePath);
-            await fs.mkdir(dir, { recursive: true });
-        }
-        await fs.writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8');
-        logger.info(`Session saved to ${filePath}`, {
-            breakpointCount: session.breakpoints.length,
-        });
-        return filePath;
-    }
-    async loadSessionFromFile(filePath) {
-        const resolvedPath = await this.validateFilePath(filePath);
-        const content = await this.readSessionFile(resolvedPath);
-        const session = JSON.parse(content);
-        await this.importSession(session);
-        logger.info(`Session loaded from ${resolvedPath}`, {
-            breakpointCount: session.breakpoints.length,
-        });
-    }
-    async importSession(sessionData) {
-        if (!this.debuggerManager.isEnabled()) {
-            throw new Error('Debugger must be enabled before importing session. Call init() or enable() first.');
-        }
-        const session = typeof sessionData === 'string' ? JSON.parse(sessionData) : sessionData;
-        if (session.version !== '1.0') {
-            logger.warn(`Session version mismatch: ${session.version} (expected 1.0)`);
-        }
-        logger.info('Importing session...', {
-            breakpointCount: session.breakpoints.length,
-            pauseOnExceptions: session.pauseOnExceptions,
-            timestamp: new Date(session.timestamp).toISOString(),
-        });
-        await this.debuggerManager.clearAllBreakpoints();
-        let successCount = 0;
-        let failCount = 0;
-        await this.processInBatches(session.breakpoints, this.SESSION_IMPORT_BATCH_SIZE, async (bp) => {
-            try {
-                if (bp.location.url) {
-                    await this.debuggerManager.setBreakpointByUrl({
-                        url: bp.location.url,
-                        lineNumber: bp.location.lineNumber,
-                        columnNumber: bp.location.columnNumber,
-                        condition: bp.condition,
-                    });
-                    successCount++;
-                }
-                else if (bp.location.scriptId) {
-                    await this.debuggerManager.setBreakpoint({
-                        scriptId: bp.location.scriptId,
-                        lineNumber: bp.location.lineNumber,
-                        columnNumber: bp.location.columnNumber,
-                        condition: bp.condition,
-                    });
-                    successCount++;
-                }
-                else {
-                    logger.warn('Breakpoint has neither url nor scriptId, skipping', bp);
-                    failCount++;
-                }
-            }
-            catch (error) {
-                logger.error('Failed to restore breakpoint:', error, bp);
-                failCount++;
-            }
-        });
-        if (session.pauseOnExceptions) {
-            await this.debuggerManager.setPauseOnExceptions(session.pauseOnExceptions);
-        }
-        logger.info('Session imported', {
-            totalBreakpoints: session.breakpoints.length,
-            successCount,
-            failCount,
-            pauseOnExceptions: session.pauseOnExceptions,
-        });
-    }
-    async listSavedSessions() {
-        const sessionsDir = path.join(process.cwd(), 'debugger-sessions');
-        try {
-            await fs.access(sessionsDir);
-        }
-        catch {
-            return [];
-        }
-        const files = await fs.readdir(sessionsDir);
-        const sessions = [];
-        const sessionFiles = files.filter((file) => file.endsWith('.json'));
-        await this.processInBatches(sessionFiles, this.SESSION_FILE_READ_BATCH_SIZE, async (file) => {
-            const filePath = path.join(sessionsDir, file);
-            try {
-                const content = await this.readSessionFile(filePath);
-                const session = JSON.parse(content);
-                sessions.push({
-                    path: filePath,
-                    timestamp: session.timestamp,
-                    metadata: session.metadata,
-                });
-            }
-            catch (error) {
-                logger.warn(`Failed to read session file ${file}:`, error);
-            }
-        });
-        sessions.sort((a, b) => b.timestamp - a.timestamp);
-        return sessions;
-    }
-}