@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/server/domains/browser/manifest.js

@@ -1,227 +0,0 @@
-import { bindByDepKey, ensureBrowserCore, toolLookup } from '../../domains/shared/registry.js';
-import { browserTools, advancedBrowserToolDefinitions } from '../../domains/browser/definitions.js';
-import { BrowserToolHandlers } from '../../domains/browser/index.js';
-const DOMAIN = 'browser';
-const DEP_KEY = 'browserHandlers';
-const t = toolLookup([...browserTools, ...advancedBrowserToolDefinitions]);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    ensureBrowserCore(ctx);
-    if (!ctx.browserHandlers) {
-        ctx.browserHandlers = new BrowserToolHandlers(ctx.collector, ctx.pageController, ctx.domInspector, ctx.scriptManager, ctx.consoleMonitor);
-    }
-    return ctx.browserHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    workflowRule: {
-        patterns: [
-            /(browser|page|navigate|screenshot|click|type|scrape)/i,
-            /(浏览器|页面|导航|截图|点击|输入|爬取)/i,
-        ],
-        priority: 90,
-        tools: ['page_navigate', 'page_screenshot', 'page_click', 'page_type', 'page_evaluate'],
-        hint: 'Browser automation workflow: bootstrap browser/page state -> navigate -> interact -> extract data',
-    },
-    prerequisites: {
-        page_navigate: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_click: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_type: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_screenshot: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_evaluate: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_hover: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_scroll: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_back: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_forward: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        page_reload: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        dom_get_structure: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-        dom_query_selector: [
-            { condition: 'Browser must be launched', fix: 'Call browser_launch or browser_attach first' },
-        ],
-    },
-    registrations: [
-        { tool: t('get_detailed_data'), domain: DOMAIN, bind: b((h, a) => h.handleGetDetailedData(a)) },
-        { tool: t('browser_attach'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserAttach(a)) },
-        { tool: t('browser_list_tabs'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserListTabs(a)) },
-        {
-            tool: t('browser_select_tab'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleBrowserSelectTab(a)),
-        },
-        { tool: t('browser_launch'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserLaunch(a)) },
-        { tool: t('browser_close'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserClose(a)) },
-        { tool: t('browser_status'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserStatus(a)) },
-        { tool: t('page_navigate'), domain: DOMAIN, bind: b((h, a) => h.handlePageNavigate(a)) },
-        { tool: t('page_reload'), domain: DOMAIN, bind: b((h, a) => h.handlePageReload(a)) },
-        { tool: t('page_back'), domain: DOMAIN, bind: b((h, a) => h.handlePageBack(a)) },
-        { tool: t('page_forward'), domain: DOMAIN, bind: b((h, a) => h.handlePageForward(a)) },
-        {
-            tool: t('dom_query_selector'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDOMQuerySelector(a)),
-        },
-        { tool: t('dom_query_all'), domain: DOMAIN, bind: b((h, a) => h.handleDOMQueryAll(a)) },
-        { tool: t('dom_get_structure'), domain: DOMAIN, bind: b((h, a) => h.handleDOMGetStructure(a)) },
-        {
-            tool: t('dom_find_clickable'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDOMFindClickable(a)),
-        },
-        { tool: t('page_click'), domain: DOMAIN, bind: b((h, a) => h.handlePageClick(a)) },
-        { tool: t('page_type'), domain: DOMAIN, bind: b((h, a) => h.handlePageType(a)) },
-        { tool: t('page_select'), domain: DOMAIN, bind: b((h, a) => h.handlePageSelect(a)) },
-        { tool: t('page_hover'), domain: DOMAIN, bind: b((h, a) => h.handlePageHover(a)) },
-        { tool: t('page_scroll'), domain: DOMAIN, bind: b((h, a) => h.handlePageScroll(a)) },
-        {
-            tool: t('page_wait_for_selector'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageWaitForSelector(a)),
-        },
-        { tool: t('page_evaluate'), domain: DOMAIN, bind: b((h, a) => h.handlePageEvaluate(a)) },
-        { tool: t('page_screenshot'), domain: DOMAIN, bind: b((h, a) => h.handlePageScreenshot(a)) },
-        { tool: t('get_all_scripts'), domain: DOMAIN, bind: b((h, a) => h.handleGetAllScripts(a)) },
-        { tool: t('get_script_source'), domain: DOMAIN, bind: b((h, a) => h.handleGetScriptSource(a)) },
-        { tool: t('console_enable'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleEnable(a)) },
-        { tool: t('console_get_logs'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleGetLogs(a)) },
-        { tool: t('console_execute'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleExecute(a)) },
-        {
-            tool: t('dom_get_computed_style'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDOMGetComputedStyle(a)),
-        },
-        { tool: t('dom_find_by_text'), domain: DOMAIN, bind: b((h, a) => h.handleDOMFindByText(a)) },
-        { tool: t('dom_get_xpath'), domain: DOMAIN, bind: b((h, a) => h.handleDOMGetXPath(a)) },
-        {
-            tool: t('dom_is_in_viewport'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDOMIsInViewport(a)),
-        },
-        {
-            tool: t('page_get_performance'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageGetPerformance(a)),
-        },
-        {
-            tool: t('page_inject_script'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageInjectScript(a)),
-        },
-        { tool: t('page_set_cookies'), domain: DOMAIN, bind: b((h, a) => h.handlePageSetCookies(a)) },
-        { tool: t('page_get_cookies'), domain: DOMAIN, bind: b((h, a) => h.handlePageGetCookies(a)) },
-        {
-            tool: t('page_clear_cookies'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageClearCookies(a)),
-        },
-        { tool: t('page_set_viewport'), domain: DOMAIN, bind: b((h, a) => h.handlePageSetViewport(a)) },
-        {
-            tool: t('page_emulate_device'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageEmulateDevice(a)),
-        },
-        {
-            tool: t('page_get_local_storage'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageGetLocalStorage(a)),
-        },
-        {
-            tool: t('page_set_local_storage'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageSetLocalStorage(a)),
-        },
-        { tool: t('page_press_key'), domain: DOMAIN, bind: b((h, a) => h.handlePagePressKey(a)) },
-        {
-            tool: t('page_get_all_links'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handlePageGetAllLinks(a)),
-        },
-        { tool: t('captcha_detect'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaDetect(a)) },
-        { tool: t('captcha_wait'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaWait(a)) },
-        { tool: t('captcha_config'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaConfig(a)) },
-        { tool: t('stealth_inject'), domain: DOMAIN, bind: b((h, a) => h.handleStealthInject(a)) },
-        {
-            tool: t('stealth_set_user_agent'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleStealthSetUserAgent(a)),
-        },
-        {
-            tool: t('stealth_configure_jitter'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleStealthConfigureJitter(a)),
-        },
-        {
-            tool: t('stealth_generate_fingerprint'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleStealthGenerateFingerprint(a)),
-        },
-        {
-            tool: t('stealth_verify'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleStealthVerify(a)),
-        },
-        {
-            tool: t('camoufox_server_launch'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCamoufoxServerLaunch(a)),
-        },
-        {
-            tool: t('camoufox_server_close'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCamoufoxServerClose(a)),
-        },
-        {
-            tool: t('camoufox_server_status'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCamoufoxServerStatus(a)),
-        },
-        {
-            tool: t('framework_state_extract'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleFrameworkStateExtract(a)),
-        },
-        { tool: t('indexeddb_dump'), domain: DOMAIN, bind: b((h, a) => h.handleIndexedDBDump(a)) },
-        { tool: t('js_heap_search'), domain: DOMAIN, bind: b((h, a) => h.handleJSHeapSearch(a)) },
-        { tool: t('tab_workflow'), domain: DOMAIN, bind: b((h, a) => h.handleTabWorkflow(a)) },
-        { tool: t('human_mouse'), domain: DOMAIN, bind: b((h, a) => h.handleHumanMouse(a)) },
-        { tool: t('human_scroll'), domain: DOMAIN, bind: b((h, a) => h.handleHumanScroll(a)) },
-        { tool: t('human_typing'), domain: DOMAIN, bind: b((h, a) => h.handleHumanTyping(a)) },
-        {
-            tool: t('captcha_vision_solve'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleCaptchaVisionSolve(a)),
-        },
-        {
-            tool: t('widget_challenge_solve'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleWidgetChallengeSolve(a)),
-        },
-    ],
-};
-export default manifest;

package/dist/src/server/domains/coordination/definitions.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const coordinationTools: Tool[];

package/dist/src/server/domains/coordination/definitions.js

@@ -1,52 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-export const coordinationTools = [
-    tool('create_task_handoff')
-        .desc('Create a sub-task handoff for specialist agent delegation. Auto-captures active page URL.')
-        .string('description', 'What the specialist should accomplish')
-        .array('constraints', { type: 'string' }, 'Constraints for the specialist')
-        .string('targetDomain', 'Suggested domain for the specialist')
-        .required('description')
-        .build(),
-    tool('complete_task_handoff')
-        .desc('Complete a task handoff with results. Transitions status to completed.')
-        .string('taskId', 'Task ID from create_task_handoff')
-        .string('summary', 'Concise summary of what was accomplished')
-        .array('keyFindings', { type: 'string' }, 'Key discoveries or results')
-        .array('artifacts', { type: 'string' }, 'Paths to generated artifact files')
-        .required('taskId', 'summary')
-        .build(),
-    tool('get_task_context')
-        .desc('Read task handoff context. Without taskId returns all active handoffs + session insights.')
-        .string('taskId', 'Specific task ID to retrieve')
-        .readOnly()
-        .idempotent()
-        .build(),
-    tool('append_session_insight')
-        .desc('Append a discovery to the session-level knowledge accumulator shared across handoffs')
-        .enum('category', ['auth', 'crypto', 'api', 'anti_debug', 'architecture', 'vulnerability', 'other'], 'Insight category')
-        .string('content', 'The insight content')
-        .prop('confidence', {
-        type: 'number',
-        description: 'Confidence level 0.0-1.0',
-        minimum: 0,
-        maximum: 1,
-    })
-        .required('category', 'content')
-        .build(),
-    tool('save_page_snapshot')
-        .desc('Save current page state (URL, cookies, storage) for checkpoint/restore workflows')
-        .string('label', 'Human-readable label for this snapshot')
-        .readOnly()
-        .build(),
-    tool('restore_page_snapshot')
-        .desc('Restore a saved page snapshot — navigates to URL and reinjects cookies and storage')
-        .string('snapshotId', 'Snapshot ID from save_page_snapshot')
-        .required('snapshotId')
-        .idempotent()
-        .build(),
-    tool('list_page_snapshots')
-        .desc('List all saved page snapshots in the current session')
-        .readOnly()
-        .idempotent()
-        .build(),
-];

package/dist/src/server/domains/coordination/index.d.ts

@@ -1,53 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-export * from './definitions.js';
-export interface TaskHandoff {
-    id: string;
-    status: 'pending' | 'in_progress' | 'completed' | 'failed';
-    description: string;
-    constraints?: string[];
-    targetDomain?: string;
-    pageUrl?: string;
-    createdAt: number;
-    completedAt?: number;
-    summary?: string;
-    keyFindings?: string[];
-    artifacts?: string[];
-}
-export interface SessionInsight {
-    id: string;
-    category: string;
-    content: string;
-    confidence: number;
-    timestamp: number;
-    sourceTaskId?: string;
-}
-export declare class CoordinationHandlers {
-    private readonly handoffs;
-    private readonly insights;
-    private readonly ctx;
-    constructor(ctx: MCPServerContext);
-    handleCreateTaskHandoff(args: Record<string, unknown>): Promise<unknown>;
-    handleCompleteTaskHandoff(args: Record<string, unknown>): Promise<unknown>;
-    handleGetTaskContext(args: Record<string, unknown>): Promise<unknown>;
-    handleAppendSessionInsight(args: Record<string, unknown>): Promise<unknown>;
-    private serializeHandoff;
-    private getInsightCountByCategory;
-    private readonly snapshots;
-    handleSavePageSnapshot(args: Record<string, unknown>): Promise<unknown>;
-    handleRestorePageSnapshot(args: Record<string, unknown>): Promise<unknown>;
-    handleListPageSnapshots(): Promise<unknown>;
-}
-export interface PageSnapshot {
-    id: string;
-    url: string;
-    cookies: Array<{
-        name: string;
-        value: string;
-        domain: string;
-        path: string;
-    }>;
-    localStorage: Record<string, string>;
-    sessionStorage: Record<string, string>;
-    timestamp: number;
-    label?: string;
-}

package/dist/src/server/domains/coordination/index.js

@@ -1,278 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export * from './definitions.js';
-export class CoordinationHandlers {
-    handoffs = new Map();
-    insights = [];
-    ctx;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    async handleCreateTaskHandoff(args) {
-        const description = args.description;
-        const constraints = args.constraints;
-        const targetDomain = args.targetDomain;
-        let pageUrl;
-        try {
-            const pc = this.ctx.pageController;
-            if (pc) {
-                const resolvedPage = await pc.getPage?.();
-                if (resolvedPage && typeof resolvedPage.url === 'function') {
-                    pageUrl = resolvedPage.url();
-                }
-            }
-        }
-        catch {
-        }
-        const handoff = {
-            id: randomUUID().slice(0, 8),
-            status: 'pending',
-            description,
-            constraints,
-            targetDomain,
-            pageUrl,
-            createdAt: Date.now(),
-        };
-        this.handoffs.set(handoff.id, handoff);
-        return {
-            taskId: handoff.id,
-            status: handoff.status,
-            description: handoff.description,
-            constraints: handoff.constraints,
-            targetDomain: handoff.targetDomain,
-            pageUrl: handoff.pageUrl,
-            createdAt: new Date(handoff.createdAt).toISOString(),
-            totalActiveHandoffs: this.handoffs.size,
-        };
-    }
-    async handleCompleteTaskHandoff(args) {
-        const taskId = args.taskId;
-        const summary = args.summary;
-        const keyFindings = args.keyFindings;
-        const artifacts = args.artifacts;
-        const handoff = this.handoffs.get(taskId);
-        if (!handoff) {
-            throw new Error(`Task handoff "${taskId}" not found. Active IDs: ${[...this.handoffs.keys()].join(', ') || '(none)'}`);
-        }
-        if (handoff.status === 'completed') {
-            throw new Error(`Task handoff "${taskId}" is already completed`);
-        }
-        handoff.status = 'completed';
-        handoff.completedAt = Date.now();
-        handoff.summary = summary;
-        handoff.keyFindings = keyFindings;
-        handoff.artifacts = artifacts;
-        return {
-            taskId: handoff.id,
-            status: 'completed',
-            summary: handoff.summary,
-            keyFindings: handoff.keyFindings,
-            artifacts: handoff.artifacts,
-            durationMs: handoff.completedAt - handoff.createdAt,
-        };
-    }
-    async handleGetTaskContext(args) {
-        const taskId = args.taskId;
-        if (taskId) {
-            const handoff = this.handoffs.get(taskId);
-            if (!handoff) {
-                throw new Error(`Task handoff "${taskId}" not found`);
-            }
-            return { handoff: this.serializeHandoff(handoff) };
-        }
-        const handoffs = [...this.handoffs.values()].map((h) => this.serializeHandoff(h));
-        const active = handoffs.filter((h) => h.status !== 'completed');
-        const completed = handoffs.filter((h) => h.status === 'completed');
-        return {
-            active,
-            completed,
-            sessionInsights: this.insights.map((i) => ({
-                id: i.id,
-                category: i.category,
-                content: i.content,
-                confidence: i.confidence,
-                timestamp: new Date(i.timestamp).toISOString(),
-                sourceTaskId: i.sourceTaskId,
-            })),
-            summary: {
-                totalActive: active.length,
-                totalCompleted: completed.length,
-                totalInsights: this.insights.length,
-            },
-        };
-    }
-    async handleAppendSessionInsight(args) {
-        const category = args.category;
-        const content = args.content;
-        const confidence = args.confidence ?? 1.0;
-        const activeHandoff = [...this.handoffs.values()].find((h) => h.status === 'in_progress' || h.status === 'pending');
-        const insight = {
-            id: randomUUID().slice(0, 8),
-            category,
-            content,
-            confidence,
-            timestamp: Date.now(),
-            sourceTaskId: activeHandoff?.id,
-        };
-        this.insights.push(insight);
-        return {
-            insightId: insight.id,
-            category: insight.category,
-            totalInsights: this.insights.length,
-            totalByCategory: this.getInsightCountByCategory(),
-        };
-    }
-    serializeHandoff(h) {
-        return {
-            taskId: h.id,
-            status: h.status,
-            description: h.description,
-            constraints: h.constraints,
-            targetDomain: h.targetDomain,
-            pageUrl: h.pageUrl,
-            createdAt: new Date(h.createdAt).toISOString(),
-            completedAt: h.completedAt ? new Date(h.completedAt).toISOString() : undefined,
-            summary: h.summary,
-            keyFindings: h.keyFindings,
-            artifacts: h.artifacts,
-        };
-    }
-    getInsightCountByCategory() {
-        const counts = {};
-        for (const insight of this.insights) {
-            counts[insight.category] = (counts[insight.category] ?? 0) + 1;
-        }
-        return counts;
-    }
-    snapshots = new Map();
-    async handleSavePageSnapshot(args) {
-        const label = args.label;
-        const pc = this.ctx.pageController;
-        if (!pc)
-            throw new Error('No page controller available');
-        const page = await pc.getPage();
-        if (!page)
-            throw new Error('No active page to snapshot');
-        const url = page.url();
-        let cookies = [];
-        try {
-            const cdp = await page.createCDPSession();
-            const result = (await cdp.send('Network.getAllCookies'));
-            cookies = result.cookies.map((c) => ({
-                name: c.name,
-                value: c.value,
-                domain: c.domain,
-                path: c.path,
-            }));
-            await cdp.detach();
-        }
-        catch {
-        }
-        let localStorage = {};
-        let sessionStorage = {};
-        try {
-            localStorage = await page.evaluate(() => {
-                const ls = {};
-                for (let i = 0; i < window.localStorage.length; i++) {
-                    const key = window.localStorage.key(i);
-                    if (key)
-                        ls[key] = window.localStorage.getItem(key) ?? '';
-                }
-                return ls;
-            });
-            sessionStorage = await page.evaluate(() => {
-                const ss = {};
-                for (let i = 0; i < window.sessionStorage.length; i++) {
-                    const key = window.sessionStorage.key(i);
-                    if (key)
-                        ss[key] = window.sessionStorage.getItem(key) ?? '';
-                }
-                return ss;
-            });
-        }
-        catch {
-        }
-        const snapshot = {
-            id: randomUUID().slice(0, 8),
-            url,
-            cookies,
-            localStorage,
-            sessionStorage,
-            timestamp: Date.now(),
-            label,
-        };
-        this.snapshots.set(snapshot.id, snapshot);
-        return {
-            snapshotId: snapshot.id,
-            url: snapshot.url,
-            cookieCount: snapshot.cookies.length,
-            localStorageKeys: Object.keys(snapshot.localStorage).length,
-            sessionStorageKeys: Object.keys(snapshot.sessionStorage).length,
-            label: snapshot.label,
-        };
-    }
-    async handleRestorePageSnapshot(args) {
-        const snapshotId = args.snapshotId;
-        if (!snapshotId)
-            throw new Error('snapshotId is required');
-        const snapshot = this.snapshots.get(snapshotId);
-        if (!snapshot)
-            throw new Error(`Snapshot "${snapshotId}" not found`);
-        const pc = this.ctx.pageController;
-        if (!pc)
-            throw new Error('No page controller available');
-        const page = await pc.getPage();
-        if (!page)
-            throw new Error('No active page for restoration');
-        await page.goto(snapshot.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-        if (snapshot.cookies.length > 0) {
-            try {
-                const cdp = await page.createCDPSession();
-                await cdp.send('Network.setCookies', {
-                    cookies: snapshot.cookies.map((c) => ({
-                        name: c.name,
-                        value: c.value,
-                        domain: c.domain,
-                        path: c.path,
-                    })),
-                });
-                await cdp.detach();
-            }
-            catch {
-            }
-        }
-        try {
-            await page.evaluate((ls, ss) => {
-                window.localStorage.clear();
-                for (const [k, v] of Object.entries(ls)) {
-                    window.localStorage.setItem(k, v);
-                }
-                window.sessionStorage.clear();
-                for (const [k, v] of Object.entries(ss)) {
-                    window.sessionStorage.setItem(k, v);
-                }
-            }, snapshot.localStorage, snapshot.sessionStorage);
-        }
-        catch {
-        }
-        return {
-            restored: true,
-            snapshotId: snapshot.id,
-            url: snapshot.url,
-            cookiesRestored: snapshot.cookies.length,
-            localStorageKeysRestored: Object.keys(snapshot.localStorage).length,
-            sessionStorageKeysRestored: Object.keys(snapshot.sessionStorage).length,
-        };
-    }
-    async handleListPageSnapshots() {
-        const list = [...this.snapshots.values()].map((s) => ({
-            id: s.id,
-            url: s.url,
-            label: s.label,
-            cookieCount: s.cookies.length,
-            localStorageKeys: Object.keys(s.localStorage).length,
-            sessionStorageKeys: Object.keys(s.sessionStorage).length,
-            createdAt: new Date(s.timestamp).toISOString(),
-        }));
-        return { snapshots: list, total: list.length };
-    }
-}

package/dist/src/server/domains/coordination/manifest.d.ts

@@ -1,57 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-import { CoordinationHandlers } from '../../domains/coordination/index.js';
-type H = CoordinationHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "coordination";
-    depKey: "coordinationHandlers";
-    profiles: ("workflow" | "full")[];
-    ensure: typeof ensure;
-    registrations: {
-        tool: {
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            name: string;
-            description?: string | undefined;
-            outputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            execution?: {
-                taskSupport?: "optional" | "required" | "forbidden" | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        };
-        domain: "coordination";
-        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;