wowdump 0.2.0 → 0.3.1

package/dist/mcp.js

@@ -1,924 +0,0 @@
-import { resolve } from "node:path";
-import { fromJsonSchema, McpServer } from "@modelcontextprotocol/server";
-import { buildAdapterRegistry } from "./adapters.js";
-import { createDryRunReport } from "./dry-run.js";
-import { readErrorLog } from "./error-log.js";
-import { discoverInstalls, discoverInstallsAcrossRoots } from "./discovery.js";
-import { listWowProcesses } from "./processes.js";
-import { createWowAnalysisService } from "./wow-analysis.js";
-export const MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
-export const MCP_SERVER_NAME = "wowdump";
-export const MCP_SERVER_VERSION = "0.2.0";
-export const LATEST_ERRORS_RESOURCE_URI = "wow-lua-errors://latest";
-const ERROR_EVENT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        schema: { const: 1 },
-        type: { const: "lua_error" },
-        timestamp: { type: "number" },
-        pid: { type: "number" },
-        threadId: { type: "number" },
-        buildKey: { type: "string" },
-        flavor: { type: "string" },
-        addon: { type: "string" },
-        message: { type: "string" },
-        stack: { type: "string" },
-        sourceAddress: { type: "string" }
-    },
-    required: ["schema", "type", "timestamp", "pid", "buildKey", "flavor", "message"]
-};
-const ERROR_LOG_RESULT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        events: { type: "array", items: ERROR_EVENT_SCHEMA },
-        diagnostics: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                    line: { type: "number" },
-                    code: { type: "string", enum: ["invalid_json", "invalid_event"] },
-                    message: { type: "string" }
-                },
-                required: ["line", "code", "message"]
-            }
-        }
-    },
-    required: ["events", "diagnostics"]
-};
-const ERROR_LOG_QUERY_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        limit: { type: "integer", minimum: 1, maximum: 1000 },
-        pid: { type: "integer", minimum: 1 },
-        buildKey: { type: "string", minLength: 1 },
-        flavor: { type: "string", minLength: 1 },
-        addon: { type: "string", minLength: 1 }
-    }
-};
-const JSON_VALUE_SCHEMA = {
-    anyOf: [
-        { type: "null" },
-        { type: "boolean" },
-        { type: "number" },
-        { type: "string" },
-        { type: "array", items: {} },
-        { type: "object", additionalProperties: true }
-    ]
-};
-const MUTATION_CONTRACT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        mutationPlanId: { type: "string", minLength: 1 },
-        confirmation: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                clientId: { type: "string", minLength: 1 },
-                confirmedAt: { type: "string", minLength: 1 },
-                nonce: { type: "string", minLength: 1 },
-                irreversibleAcknowledged: { type: "boolean" }
-            },
-            required: ["clientId", "confirmedAt", "nonce"]
-        },
-        target: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                pid: { type: "integer", minimum: 1 },
-                buildKey: { anyOf: [{ type: "string", minLength: 1 }, { type: "null" }] }
-            },
-            required: ["pid", "buildKey"]
-        },
-        expectedEffect: JSON_VALUE_SCHEMA,
-        rollback: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                mode: { type: "string", enum: ["reversible", "compensating", "irreversible"] },
-                plan: JSON_VALUE_SCHEMA,
-                deadline: { type: "string", minLength: 1 },
-                successOracle: JSON_VALUE_SCHEMA,
-                irreversibleReason: { type: "string", minLength: 1 }
-            },
-            required: ["mode"]
-        },
-        evidencePlan: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                before: JSON_VALUE_SCHEMA,
-                after: JSON_VALUE_SCHEMA,
-                rollback: JSON_VALUE_SCHEMA
-            },
-            required: ["before", "after"]
-        },
-        audit: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                actor: { type: "string", minLength: 1 },
-                reason: { type: "string", minLength: 1 },
-                requestId: { type: "string", minLength: 1 }
-            },
-            required: ["actor", "reason", "requestId"]
-        }
-    },
-    required: ["mutationPlanId", "confirmation", "target", "expectedEffect", "rollback", "evidencePlan", "audit"]
-};
-const LAUNCH_CONTRACT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        mutationPlanId: { type: "string", minLength: 1 },
-        confirmation: MUTATION_CONTRACT_SCHEMA.properties?.confirmation ?? { type: "object" },
-        launchSpec: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                executable: { type: "string", minLength: 1 },
-                argv: { type: "array", items: { type: "string" }, maxItems: 256 },
-                cwd: { type: "string", minLength: 1 },
-                environmentDigest: { type: "string", pattern: "^[A-Fa-f0-9]{64}$" },
-                suspended: { type: "boolean" }
-            },
-            required: ["executable", "argv", "cwd", "environmentDigest", "suspended"]
-        },
-        expectedBuildKey: { anyOf: [{ type: "string", minLength: 1 }, { type: "null" }] },
-        expectedEffect: MUTATION_CONTRACT_SCHEMA.properties?.expectedEffect ?? JSON_VALUE_SCHEMA,
-        rollback: MUTATION_CONTRACT_SCHEMA.properties?.rollback ?? { type: "object" },
-        evidencePlan: MUTATION_CONTRACT_SCHEMA.properties?.evidencePlan ?? { type: "object" },
-        audit: MUTATION_CONTRACT_SCHEMA.properties?.audit ?? { type: "object" }
-    },
-    required: ["mutationPlanId", "confirmation", "launchSpec", "expectedEffect", "rollback", "evidencePlan", "audit"]
-};
-/**
- * One MCP entry point for the Frida host API and GumJS surface.  The explicit
- * operations cover the common host-side commands; `script` and `script_load`
- * keep the complete Frida JavaScript API available for build-specific work.
- */
-const FRIDA_COMMAND_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        operation: {
-            type: "string",
-            enum: [
-                "devices",
-                "host_call",
-                "processes",
-                "applications",
-                "spawn",
-                "resume",
-                "kill",
-                "attach",
-                "detach",
-                "session_status",
-                "modules",
-                "exports",
-                "ranges",
-                "read_memory",
-                "write_memory",
-                "protect_memory",
-                "scan_memory",
-                "script",
-                "script_load",
-                "script_call",
-                "script_unload",
-                "compile_script",
-                "handle_release"
-            ]
-        },
-        deviceId: { type: "string", minLength: 1 },
-        requestId: { type: "string", minLength: 1 },
-        pid: { type: "integer", minimum: 1 },
-        buildKey: { type: "string", minLength: 1 },
-        flavor: { type: "string", minLength: 1 },
-        sessionId: { type: "string", minLength: 1 },
-        scriptId: { type: "string", minLength: 1 },
-        resourceId: { type: "string", minLength: 1 },
-        module: { type: "string", minLength: 1 },
-        protection: { type: "string", minLength: 1 },
-        address: { type: "string", minLength: 1 },
-        size: { type: "integer", minimum: 1, maximum: 16777216 },
-        bytesHex: { type: "string", minLength: 2, maxLength: 33554432 },
-        hex: { type: "string", minLength: 2, maxLength: 33554432 },
-        pattern: { type: "string", minLength: 1 },
-        source: { type: "string", minLength: 1, maxLength: 4194304 },
-        exportName: { type: "string", minLength: 1 },
-        args: { type: "array", items: {} },
-        program: { type: "string", minLength: 1 },
-        argv: { type: "array", items: { type: "string" } },
-        options: { type: "object", additionalProperties: true },
-        timeoutMs: { type: "integer", minimum: 1, maximum: 120000 },
-        persist: { type: "boolean" },
-        coalesce: { type: "boolean" },
-        scope: { type: "string", enum: ["api", "device", "session"] },
-        method: { type: "string", minLength: 1 },
-        mutation: MUTATION_CONTRACT_SCHEMA,
-        launch: LAUNCH_CONTRACT_SCHEMA
-    },
-    required: ["operation"],
-    allOf: [
-        {
-            if: { properties: { operation: { const: "handle_release" } } },
-            then: { required: ["resourceId"] }
-        }
-    ]
-};
-const FRIDA_COMMAND_RESULT_SCHEMA = {
-    type: "object",
-    additionalProperties: true
-};
-const BUILD_TARGET_PROPERTIES = {
-    pid: { type: "integer", minimum: 1 },
-    buildKey: { type: "string", minLength: 1 }
-};
-const TRACE_SELECTOR_PROPERTIES = {
-    APIs: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 512 },
-    apis: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 512 },
-    namespace: { type: "string", minLength: 1 },
-    glob: { type: "string", minLength: 1 },
-    rva: {},
-    all: { type: "boolean" }
-};
-const WOW_LUA_TRACE_START_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        ...BUILD_TARGET_PROPERTIES,
-        ...TRACE_SELECTOR_PROPERTIES,
-        captureArgs: { type: "boolean" },
-        captureReturns: { type: "boolean" },
-        captureNativeArguments: { type: "boolean" },
-        tableDepth: { type: "integer", minimum: 0, maximum: 8 },
-        maxItems: { type: "integer", minimum: 1, maximum: 1024 },
-        maxStringBytes: { type: "integer", minimum: 1, maximum: 1048576 },
-        maxStackValues: { type: "integer", minimum: 1, maximum: 4096 },
-        maxInvocationDepth: { type: "integer", minimum: 1, maximum: 1024 },
-        maxDecodeMs: { type: "integer", minimum: 1, maximum: 1000 },
-        maxEvents: { type: "integer", minimum: 1, maximum: 100000 },
-        maxHooks: { type: "integer", minimum: 1, maximum: 512 },
-        sampling: { type: "number", exclusiveMinimum: 0, maximum: 1 },
-        durationMs: { type: "integer", minimum: 0, maximum: 86400000 },
-        allowTableIteration: { type: "boolean" },
-        staleInvocationMs: { type: "integer", minimum: 100, maximum: 600000 }
-    },
-    required: ["buildKey"]
-};
-const WOW_CPP_TRACE_START_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        ...BUILD_TARGET_PROPERTIES,
-        ...TRACE_SELECTOR_PROPERTIES,
-        clusterIds: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        captureArguments: { type: "boolean" },
-        captureReturn: { type: "boolean" },
-        argumentCount: { type: "integer", minimum: 0, maximum: 32 },
-        maxEvents: { type: "integer", minimum: 1, maximum: 100000 },
-        maxHooks: { type: "integer", minimum: 1, maximum: 256 },
-        sampling: { type: "number", exclusiveMinimum: 0, maximum: 1 },
-        durationMs: { type: "integer", minimum: 0, maximum: 86400000 }
-    },
-    required: ["buildKey"]
-};
-const WOW_TRACE_READ_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        afterSeq: { type: "integer", minimum: 0 },
-        limit: { type: "integer", minimum: 1, maximum: 10000 }
-    }
-};
-const WOW_TRACE_STOP_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: { reason: { type: "string", minLength: 1, maxLength: 256 } }
-};
-const EMPTY_INPUT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {}
-};
-const DISCOVERY_RESULT_SCHEMA = {
-    type: "object",
-    additionalProperties: true
-};
-const WOW_DATA_SOURCE_LIST_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        buildKey: { type: "string", minLength: 1 },
-        status: { type: "string", minLength: 1 },
-        readerStatus: { type: "string", minLength: 1 },
-        system: { type: "string", minLength: 1 },
-        offset: { type: "integer", minimum: 0 },
-        limit: { type: "integer", minimum: 1, maximum: 10000 }
-    },
-    required: ["buildKey"]
-};
-const WOW_DATA_SOURCE_DESCRIBE_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        buildKey: { type: "string", minLength: 1 },
-        dataSourceId: { type: "string", minLength: 1 }
-    },
-    required: ["buildKey", "dataSourceId"]
-};
-const WOW_DATA_READ_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        ...BUILD_TARGET_PROPERTIES,
-        dataSourceId: { type: "string", minLength: 1 },
-        limit: { type: "integer", minimum: 1, maximum: 10000 }
-    },
-    required: ["buildKey", "dataSourceId"]
-};
-const WOW_BUILD_PROFILE_VALIDATE_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        ...BUILD_TARGET_PROPERTIES,
-        maxChecks: { type: "integer", minimum: 1, maximum: 512 }
-    },
-    required: ["buildKey"]
-};
-const WOW_ANALYSIS_COVERAGE_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: { buildKey: { type: "string", minLength: 1 } },
-    required: ["buildKey"]
-};
-const WOW_ANALYSIS_CHECKPOINT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        buildKey: { type: "string", minLength: 1 },
-        label: { type: "string", minLength: 1, maxLength: 256 }
-    },
-    required: ["buildKey"]
-};
-const FOCUS_SELECTOR_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        combine: { type: "string", enum: ["all", "any"] },
-        apis: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        namespaces: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        globs: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        rvas: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        dataSourceIds: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        objectIds: { type: "array", items: { type: "string", minLength: 1 }, maxItems: 256 },
-        ranges: { type: "array", items: { type: "object", additionalProperties: false, properties: { rva: { type: "string", pattern: "^0x(?:0|[1-9A-F][0-9A-F]*)$" }, size: { type: "integer", minimum: 1, maximum: 2147483647 } }, required: ["rva", "size"] }, maxItems: 256 },
-        maxTargets: { type: "integer", minimum: 1, maximum: 256 }
-    }
-};
-const ENVIRONMENT_DESCRIPTOR_SCHEMA = {
-    type: "object",
-    additionalProperties: true,
-    minProperties: 1
-};
-const TRIGGER_PLAN_SCHEMA = {
-    type: "object",
-    additionalProperties: true,
-    minProperties: 1
-};
-const FOCUS_START_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        pid: { type: "integer", minimum: 1 },
-        buildKey: { type: "string", minLength: 1 },
-        targetKind: { type: "string", enum: ["lua_wrapper", "cpp_function", "data_source", "object", "address_range"] },
-        selector: FOCUS_SELECTOR_SCHEMA,
-        environmentDescriptor: ENVIRONMENT_DESCRIPTOR_SCHEMA,
-        triggerPlan: TRIGGER_PLAN_SCHEMA,
-        captureArgs: { type: "boolean" },
-        captureReturns: { type: "boolean" },
-        captureCallStack: { type: "boolean" },
-        captureMemoryWrites: { type: "boolean" },
-        captureObjectDiff: { type: "boolean" },
-        snapshotIntervalMs: { type: "integer", minimum: 0, maximum: 60000 },
-        maxEvents: { type: "integer", minimum: 1, maximum: 100000 },
-        maxBytes: { type: "integer", minimum: 1, maximum: 67108864 },
-        durationMs: { type: "integer", minimum: 0, maximum: 86400000 },
-        sampling: { type: "number", exclusiveMinimum: 0, maximum: 1 },
-        sessionId: { type: "string", minLength: 1 }
-    },
-    required: ["pid", "buildKey", "targetKind", "selector", "environmentDescriptor", "triggerPlan"]
-};
-const WATCH_START_SCHEMA = {
-    ...FOCUS_START_SCHEMA,
-    properties: {
-        ...(FOCUS_START_SCHEMA.properties ?? {}),
-        targetKind: { type: "string", enum: ["data_source", "object", "address_range"] }
-    }
-};
-const FOCUS_IDENTITY_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        sessionId: { type: "string", minLength: 1 },
-        pid: { type: "integer", minimum: 1 },
-        buildKey: { type: "string", minLength: 1 }
-    },
-    required: ["sessionId", "pid", "buildKey"]
-};
-const FOCUS_READ_SCHEMA = {
-    ...FOCUS_IDENTITY_SCHEMA,
-    properties: {
-        ...(FOCUS_IDENTITY_SCHEMA.properties ?? {}),
-        afterSeq: { type: "integer", minimum: 0 },
-        cursor: { type: "integer", minimum: 0 },
-        limit: { type: "integer", minimum: 1, maximum: 10000 }
-    }
-};
-const FOCUS_STOP_SCHEMA = {
-    ...FOCUS_IDENTITY_SCHEMA,
-    properties: {
-        ...(FOCUS_IDENTITY_SCHEMA.properties ?? {}),
-        reason: { type: "string", minLength: 1, maxLength: 256 }
-    }
-};
-const FOCUS_CHECKPOINT_SCHEMA = {
-    ...FOCUS_IDENTITY_SCHEMA,
-    properties: {
-        ...(FOCUS_IDENTITY_SCHEMA.properties ?? {}),
-        triggerPhase: { type: "string", enum: ["before", "during", "after"] },
-        phaseIndex: { type: "integer", minimum: 0 },
-        userAction: { type: "string", minLength: 1, maxLength: 4096 },
-        snapshotNow: { type: "boolean" }
-    },
-    required: ["sessionId", "pid", "buildKey", "triggerPhase", "phaseIndex", "userAction"]
-};
-const READ_ONLY_ANNOTATIONS = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-};
-const READ_WRITE_ANNOTATIONS = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: false,
-    openWorldHint: false
-};
-function textResult(value, isError = false) {
-    return {
-        content: [{ type: "text", text: JSON.stringify(value) }],
-        structuredContent: value,
-        ...(isError ? { isError: true } : {})
-    };
-}
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-export function createWowBuildFridaMcpServer(options) {
-    const registry = options.adapterRegistry ?? buildAdapterRegistry;
-    const discover = options.discover ?? discoverInstalls;
-    const listProcesses = options.listProcesses ?? listWowProcesses;
-    const readLog = options.readLog ?? readErrorLog;
-    const fridaRuntime = options.fridaRuntime ?? createUnavailableExecutor();
-    const analysisService = options.analysisService ?? createWowAnalysisService({
-        executor: fridaRuntime,
-        profileRoot: options.profileRoot ?? options.analysisDir ?? requiredProfileRoot()
-    });
-    const focusService = options.focusService ?? createUnavailableFocusExecutor();
-    const gameRoots = normalizeGameRoots(options);
-    const discoverAll = () => discoverInstallsAcrossRoots(gameRoots, discover);
-    const server = new McpServer({ name: MCP_SERVER_NAME, version: MCP_SERVER_VERSION }, {
-        instructions: "WoW build-aware Frida analysis. frida_command exposes host Frida operations and GumJS scripts, including explicit memory writes and process-control operations. Select a PID/buildKey for target operations; build adapters add verified build context.",
-        capabilities: { tools: {}, resources: {} }
-    });
-    const querySchema = fromJsonSchema(ERROR_LOG_QUERY_SCHEMA);
-    const resultSchema = fromJsonSchema(ERROR_LOG_RESULT_SCHEMA);
-    const fridaCommandSchema = fromJsonSchema(FRIDA_COMMAND_SCHEMA);
-    const fridaResultSchema = fromJsonSchema(FRIDA_COMMAND_RESULT_SCHEMA);
-    const discoveryResultSchema = fromJsonSchema(DISCOVERY_RESULT_SCHEMA);
-    server.registerTool("wow_install_list", {
-        title: "List WoW installations",
-        description: "List configured game roots and discovered WoW installations without attaching.",
-        inputSchema: fromJsonSchema(EMPTY_INPUT_SCHEMA),
-        outputSchema: discoveryResultSchema,
-        annotations: READ_ONLY_ANNOTATIONS
-    }, async () => textResult({
-        gameRoots,
-        installs: discoverAll().map(install => ({
-            root: install.root,
-            executable: install.executable,
-            flavor: install.flavor,
-            buildKey: install.build.buildKey,
-            build: install.build
-        }))
-    }));
-    server.registerTool("wow_build_list", {
-        title: "List WoW builds",
-        description: "List unique builds discovered across all configured game roots without attaching.",
-        inputSchema: fromJsonSchema(EMPTY_INPUT_SCHEMA),
-        outputSchema: discoveryResultSchema,
-        annotations: READ_ONLY_ANNOTATIONS
-    }, async () => {
-        const builds = new Map();
-        for (const install of discoverAll()) {
-            const current = builds.get(install.build.buildKey);
-            if (current) {
-                if (!current.flavors.includes(install.flavor))
-                    current.flavors.push(install.flavor);
-                if (!current.executables.includes(install.executable))
-                    current.executables.push(install.executable);
-            }
-            else {
-                builds.set(install.build.buildKey, {
-                    buildKey: install.build.buildKey,
-                    build: install.build,
-                    flavors: [install.flavor],
-                    executables: [install.executable]
-                });
-            }
-        }
-        return textResult({ builds: [...builds.values()] });
-    });
-    server.registerTool("wow_target_list", {
-        title: "List live WoW targets",
-        description: "List live matched WoW processes and explicitly report discovered installations with no matching process; never attaches.",
-        inputSchema: fromJsonSchema(EMPTY_INPUT_SCHEMA),
-        outputSchema: discoveryResultSchema,
-        annotations: READ_ONLY_ANNOTATIONS
-    }, async () => {
-        const installs = discoverAll();
-        try {
-            const processes = await listProcesses(installs);
-            const liveExecutables = new Set(processes.map(process => resolve(process.install.executable).toLowerCase()));
-            return textResult({
-                targets: processes.map(process => ({
-                    status: "matched",
-                    pid: process.pid,
-                    path: process.executable,
-                    flavor: process.install.flavor,
-                    buildKey: process.install.build.buildKey,
-                    module: { name: "Wow.exe", path: process.executable },
-                    startTime: process.startTime ?? null
-                })),
-                unmatched: installs.filter(install => !liveExecutables.has(resolve(install.executable).toLowerCase())).map(install => ({
-                    status: "not_running",
-                    pid: null,
-                    path: install.executable,
-                    flavor: install.flavor,
-                    buildKey: install.build.buildKey,
-                    module: { name: "Wow.exe", path: install.executable }
-                }))
-            });
-        }
-        catch (error) {
-            return textResult({ targets: [], unmatched: installs.map(install => ({
-                    status: "scan_failed",
-                    pid: null,
-                    path: install.executable,
-                    flavor: install.flavor,
-                    buildKey: install.build.buildKey,
-                    module: { name: "Wow.exe", path: install.executable }
-                })), processScanError: errorText(error) });
-        }
-    });
-    server.registerTool("list_lua_errors", {
-        title: "List Lua errors",
-        description: "Read and filter existing JSONL Lua error events.",
-        inputSchema: querySchema,
-        outputSchema: resultSchema,
-        annotations: READ_ONLY_ANNOTATIONS
-    }, async (query = {}) => {
-        try {
-            return textResult(await readLog(options.errorsFile, query));
-        }
-        catch (error) {
-            return textResult({ error: errorText(error) }, true);
-        }
-    });
-    server.registerTool("bridge_status", {
-        title: "Bridge status",
-        description: "Report discovered installs, live PIDs, adapter state, and read-only tiers.",
-        annotations: READ_ONLY_ANNOTATIONS
-    }, async () => {
-        const installs = discoverAll();
-        let processes = [];
-        let processScanError;
-        try {
-            processes = await listProcesses(installs);
-        }
-        catch (error) {
-            processScanError = errorText(error);
-        }
-        const report = createDryRunReport(installs, processes, registry);
-        return textResult({
-            protocolVersion: MCP_MODERN_PROTOCOL_VERSION,
-            semanticReadOnly: true,
-            fridaGateway: {
-                tool: "frida_command",
-                mutationCapable: true,
-                buildAware: true
-            },
-            ...report,
-            ...(processScanError ? { processScanError } : {})
-        });
-    });
-    server.registerTool("frida_command", {
-        title: "Run Frida command",
-        description: "Run a build-aware Frida host or GumJS operation. Supports device/process discovery, host_call for the complete Node Frida surface, attach/detach, modules, exports, ranges, memory read/write/protect/scan, script loading/calls, compilation, spawn, resume, and kill.",
-        inputSchema: fridaCommandSchema,
-        outputSchema: fridaResultSchema,
-        annotations: READ_WRITE_ANNOTATIONS
-    }, async (request) => {
-        try {
-            const command = request;
-            const target = await resolveFridaTarget(command, discover, listProcesses, gameRoots, registry);
-            return textResult(await fridaRuntime.execute(command, target));
-        }
-        catch (error) {
-            return textResult({ error: errorText(error) }, true);
-        }
-    });
-    const analysisTools = [
-        {
-            name: "wow_lua_trace_start",
-            title: "Start WoW Lua native trace",
-            description: "Dynamically discover the selected WoW build, validate its module base and ABI catalog, then hook only explicitly selected Lua native wrappers.",
-            schema: WOW_LUA_TRACE_START_SCHEMA,
-            annotations: READ_WRITE_ANNOTATIONS
-        },
-        {
-            name: "wow_lua_trace_read",
-            title: "Read WoW Lua trace",
-            description: "Read bounded Lua wrapper enter/leave events from the active trace ring.",
-            schema: WOW_TRACE_READ_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_lua_trace_status",
-            title: "Get WoW Lua trace status",
-            description: "Report active Lua hooks, selected records, queued events and dynamic module base.",
-            schema: EMPTY_INPUT_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_lua_trace_stop",
-            title: "Stop WoW Lua trace",
-            description: "Detach every Lua wrapper hook, dispose the script and release its owned Frida session.",
-            schema: WOW_TRACE_STOP_SCHEMA,
-            annotations: READ_WRITE_ANNOTATIONS
-        },
-        {
-            name: "wow_cpp_trace_start",
-            title: "Start indexed WoW C++ trace",
-            description: "Trace explicitly selected business callees from the build callgraph with bounded hook and event limits.",
-            schema: WOW_CPP_TRACE_START_SCHEMA,
-            annotations: READ_WRITE_ANNOTATIONS
-        },
-        {
-            name: "wow_cpp_trace_read",
-            title: "Read WoW C++ trace",
-            description: "Read bounded events from the active indexed C++ trace.",
-            schema: WOW_TRACE_READ_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_cpp_trace_status",
-            title: "Get WoW C++ trace status",
-            description: "Report active C++ hooks, dynamic base, queue depth and dropped events.",
-            schema: EMPTY_INPUT_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_cpp_trace_stop",
-            title: "Stop WoW C++ trace",
-            description: "Detach every indexed C++ hook, dispose the script and release its owned Frida session.",
-            schema: WOW_TRACE_STOP_SCHEMA,
-            annotations: READ_WRITE_ANNOTATIONS
-        },
-        {
-            name: "wow_data_source_list",
-            title: "List WoW data sources",
-            description: "List build-profile data sources and their reader/static/live verification status.",
-            schema: WOW_DATA_SOURCE_LIST_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_data_source_describe",
-            title: "Describe WoW data source",
-            description: "Describe one indexed data source, pointer chain, fields, invariants and evidence.",
-            schema: WOW_DATA_SOURCE_DESCRIBE_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_data_read",
-            title: "Read verified WoW data source",
-            description: "Read a reader_ready data source by ID using only its build profile RVA, fields and validation rules.",
-            schema: WOW_DATA_READ_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_build_profile_validate",
-            title: "Validate WoW build profile",
-            description: "Dynamically discover Wow.exe, verify build signatures at base plus RVA, and report address evidence.",
-            schema: WOW_BUILD_PROFILE_VALIDATE_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_analysis_coverage",
-            title: "Read WoW analysis coverage",
-            description: "Summarize artifact presence and Lua, C++ data-root and non-Lua coverage for a build.",
-            schema: WOW_ANALYSIS_COVERAGE_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        },
-        {
-            name: "wow_analysis_checkpoint",
-            title: "Create WoW analysis checkpoint",
-            description: "Return a recoverable coverage checkpoint and its suggested append-only process event.",
-            schema: WOW_ANALYSIS_CHECKPOINT_SCHEMA,
-            annotations: READ_ONLY_ANNOTATIONS
-        }
-    ];
-    for (const definition of analysisTools) {
-        const inputSchema = fromJsonSchema(definition.schema);
-        server.registerTool(definition.name, {
-            title: definition.title,
-            description: definition.description,
-            inputSchema,
-            outputSchema: fridaResultSchema,
-            annotations: definition.annotations
-        }, async (input = {}) => {
-            try {
-                return textResult(await analysisService.invoke(definition.name, input));
-            }
-            catch (error) {
-                return textResult({ error: errorText(error) }, true);
-            }
-        });
-    }
-    const focusTools = [
-        { name: "wow_focus_start", title: "Start focused WoW trace", description: "Start a PID/build-bound target-scoped session with before/during/after evidence.", schema: FOCUS_START_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_watch_start", title: "Start focused WoW watch", description: "Watch an explicitly selected data source, object, or address range over a bounded window.", schema: WATCH_START_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_focus_read", title: "Read focused WoW trace", description: "Read immutable focused events after a cursor.", schema: FOCUS_READ_SCHEMA, annotations: READ_ONLY_ANNOTATIONS },
-        { name: "wow_watch_read", title: "Read focused WoW watch", description: "Read immutable watch events after a cursor.", schema: FOCUS_READ_SCHEMA, annotations: READ_ONLY_ANNOTATIONS },
-        { name: "wow_focus_status", title: "Focused WoW trace status", description: "Report focused session identity, targets, buffers, drops and cleanup state.", schema: FOCUS_IDENTITY_SCHEMA, annotations: READ_ONLY_ANNOTATIONS },
-        { name: "wow_watch_status", title: "Focused WoW watch status", description: "Report watch session identity, targets, buffers, drops and cleanup state.", schema: FOCUS_IDENTITY_SCHEMA, annotations: READ_ONLY_ANNOTATIONS },
-        { name: "wow_focus_pause", title: "Pause focused WoW trace", description: "Pause event capture and record a timeline gap.", schema: FOCUS_IDENTITY_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_focus_resume", title: "Resume focused WoW trace", description: "Revalidate the target and resume event capture.", schema: FOCUS_IDENTITY_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_focus_stop", title: "Stop focused WoW trace", description: "Capture after evidence and clean every session-owned resource.", schema: FOCUS_STOP_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_watch_stop", title: "Stop focused WoW watch", description: "Capture after evidence and clean every watch-owned resource.", schema: FOCUS_STOP_SCHEMA, annotations: READ_WRITE_ANNOTATIONS },
-        { name: "wow_session_checkpoint", title: "Checkpoint focused WoW session", description: "Append a validated trigger-plan checkpoint without rewriting events.", schema: FOCUS_CHECKPOINT_SCHEMA, annotations: READ_WRITE_ANNOTATIONS }
-    ];
-    for (const definition of focusTools) {
-        const inputSchema = fromJsonSchema(definition.schema);
-        server.registerTool(definition.name, {
-            title: definition.title,
-            description: definition.description,
-            inputSchema,
-            outputSchema: fridaResultSchema,
-            annotations: definition.annotations
-        }, async (input = {}) => {
-            try {
-                return textResult(await focusService.invoke(definition.name, input));
-            }
-            catch (error) {
-                return textResult({ error: errorText(error) }, true);
-            }
-        });
-    }
-    const brokerStatusSchema = EMPTY_INPUT_SCHEMA;
-    const brokerStatus = async () => {
-        const installs = discoverAll();
-        const processes = await listProcesses(installs).catch(() => []);
-        const status = await (options.brokerControl?.status() ?? Promise.resolve({
-            status: "stopped",
-            brokerPid: null,
-            instanceId: null,
-            nextAction: "wow_broker_start"
-        }));
-        return {
-            ...status,
-            wowProcesses: processes.map(process => ({
-                pid: process.pid,
-                executable: process.executable,
-                flavor: process.install.flavor,
-                buildKey: process.install.build.buildKey,
-                startTime: process.startTime ?? null
-            }))
-        };
-    };
-    const brokerControlTools = [
-        ["wow_broker_status", "Broker status", "Read Broker state and list live Wow.exe PIDs without attaching or auto-starting.", READ_ONLY_ANNOTATIONS, brokerStatus],
-        ["wow_broker_start", "Start Broker", "Start or connect to the per-user Broker.", READ_WRITE_ANNOTATIONS, () => options.brokerControl?.start() ?? Promise.resolve({ status: "unavailable" })],
-        ["wow_broker_reconnect", "Reconnect Broker", "Reconnect MCP to the existing per-user Broker.", READ_WRITE_ANNOTATIONS, () => options.brokerControl?.reconnect() ?? Promise.resolve({ status: "unavailable" })],
-        ["wow_broker_stop", "Stop Broker", "Release this MCP lease and request graceful Broker cleanup.", READ_WRITE_ANNOTATIONS, async () => { await options.brokerControl?.close(); return { status: "stopped" }; }]
-    ];
-    for (const [name, title, description, annotations, handler] of brokerControlTools) {
-        server.registerTool(name, { title, description, inputSchema: fromJsonSchema(brokerStatusSchema), outputSchema: fridaResultSchema, annotations }, async () => textResult(await handler()));
-    }
-    server.registerResource("latest_lua_errors", LATEST_ERRORS_RESOURCE_URI, {
-        title: "Latest WoW Lua errors",
-        description: "The latest read-only snapshot from the JSONL error store.",
-        mimeType: "application/json",
-        cacheHint: { ttlMs: 0, cacheScope: "private" }
-    }, async (uri) => {
-        const result = await readLog(options.errorsFile);
-        return {
-            contents: [{
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(result)
-                }]
-        };
-    });
-    return server;
-}
-function createUnavailableExecutor() {
-    return {
-        async execute() {
-            throw new Error("Frida executor is not configured; connect MCP through the Broker gateway");
-        },
-        async close() { }
-    };
-}
-function createUnavailableFocusExecutor() {
-    return {
-        async invoke() {
-            throw new Error("Broker focus service is unavailable");
-        }
-    };
-}
-export async function resolveFridaTarget(command, discover, listProcesses, gameRoot, registry) {
-    const operation = String(command.operation ?? command.op ?? command.command ?? "");
-    const discoveryOperations = new Set(["devices", "processes", "applications", "spawn", "session_status"]);
-    if (operation === "spawn" && command.pid !== undefined) {
-        throw new Error("SPAWN_PID_MUST_BE_NULL: spawn cannot be bound to an existing PID");
-    }
-    if (operation === "spawn") {
-        const buildKey = command.buildKey;
-        return {
-            pid: undefined,
-            buildKey,
-            flavor: command.flavor,
-            adapter: buildKey ? registry.lookup(buildKey) : undefined
-        };
-    }
-    if (command.pid === undefined && !discoveryOperations.has(operation)) {
-        throw new Error("PID_REQUIRED: provide the live Wow.exe pid for this operation");
-    }
-    if (command.pid === undefined && command.buildKey === undefined && command.flavor === undefined) {
-        return undefined;
-    }
-    const installs = discoverInstallsAcrossRoots(typeof gameRoot === "string" ? [gameRoot] : gameRoot, discover);
-    const processes = await listProcesses(installs);
-    const byPid = command.pid === undefined
-        ? undefined
-        : processes.find(item => item.pid === command.pid);
-    if (command.pid !== undefined && !byPid) {
-        throw new Error(`PID_NOT_WOW: PID ${command.pid} is not a discovered Wow.exe process`);
-    }
-    if (byPid && command.buildKey && byPid.install.build.buildKey !== command.buildKey) {
-        throw new Error(`PID_BUILD_MISMATCH: PID ${byPid.pid} belongs to ${byPid.install.build.buildKey}, not ${command.buildKey}`);
-    }
-    if (byPid && command.flavor && byPid.install.flavor !== command.flavor) {
-        throw new Error(`PID_BUILD_MISMATCH: PID ${byPid.pid} belongs to flavor ${byPid.install.flavor}, not ${command.flavor}`);
-    }
-    const process = byPid ?? processes.find(item => (command.buildKey === undefined || item.install.build.buildKey === command.buildKey) &&
-        (command.flavor === undefined || item.install.flavor === command.flavor));
-    const buildKey = process?.install.build.buildKey ?? command.buildKey;
-    const flavor = process?.install.flavor ?? command.flavor;
-    const adapter = buildKey ? registry.lookup(buildKey) : undefined;
-    return {
-        pid: process?.pid ?? command.pid,
-        buildKey,
-        flavor,
-        executable: process?.executable,
-        processStartTime: process?.startTime,
-        adapter
-    };
-}
-function requiredProfileRoot() {
-    const value = process.env.WOWDUMP_PROFILE_DIR;
-    if (!value)
-        throw new Error("profileRoot is required; configure packaged build profiles");
-    return resolve(value);
-}
-function normalizeGameRoots(options) {
-    const roots = [...(options.gameRoots ?? []), ...(options.gameRoot ? [options.gameRoot] : [])];
-    const unique = new Map();
-    for (const root of roots) {
-        const trimmed = root.trim();
-        if (!trimmed)
-            continue;
-        const absolute = resolve(trimmed);
-        if (!unique.has(absolute.toLowerCase()))
-            unique.set(absolute.toLowerCase(), absolute);
-    }
-    return [...unique.values()];
-}