@opentabs-dev/mcp-server 0.0.22 → 0.0.25

package/dist/extension-protocol.js

@@ -1,131 +1,16 @@
 /**
  * Extension WebSocket protocol handler.
- * Handles JSON-RPC messages between the MCP server and Chrome extension.
+ * Handles JSON-RPC dispatch mechanics and message routing between the MCP
+ * server and Chrome extension. Individual message handlers live in
+ * extension-handlers.ts.
  */
-import { getAdaptersDir } from './config.js';
-import { appendLog } from './log-buffer.js';
+import { ensureAdaptersDir, writeAdapterFile, cleanupStaleAdapterFiles, writeExecFile, deleteExecFile, cleanupStaleExecFiles, timeoutRace, ADAPTER_WRITE_TIMEOUT_MS, } from './adapter-files.js';
+import { sendToExtension, sendJsonRpcError, serializePluginForExtension, handleTabSyncAll, handleTabStateChanged, handleConfigGetState, handleConfigSetToolEnabled, handleConfigSetAllToolsEnabled, handlePluginSearch, handlePluginInstall, handlePluginUpdateFromRegistry, handlePluginRemove, handlePluginCheckUpdates, handleToolProgress, handlePluginLog, handleConfirmationResponse, rejectAllPendingConfirmations, } from './extension-handlers.js';
 import { log } from './logger.js';
-import { prefixedToolName, isToolEnabled, getNextRequestId, DISPATCH_TIMEOUT_MS, MAX_DISPATCH_TIMEOUT_MS, CONFIRMATION_TIMEOUT_MS, } from './state.js';
-import { mkdir, readdir, rename } from 'node:fs/promises';
-import { join } from 'node:path';
-/**
- * Ensure the adapters directory exists, creating it if necessary.
- * Caches the result so mkdir is called at most once per module evaluation
- * (resets on bun --hot reload, which is correct since the config dir could change).
- */
-let adaptersDirReady = false;
-const ensureAdaptersDir = async () => {
-    if (adaptersDirReady)
-        return;
-    await mkdir(getAdaptersDir(), { recursive: true });
-    adaptersDirReady = true;
-};
+import { getNextRequestId, DISPATCH_TIMEOUT_MS, CONFIRMATION_TIMEOUT_MS } from './state.js';
+import { toErrorMessage } from '@opentabs-dev/shared';
 /** Maximum incoming WebSocket message size (10MB) */
 const MAX_MESSAGE_SIZE = 10 * 1024 * 1024;
-/** Prefix for dynamically generated exec script files */
-const EXEC_FILE_PREFIX = '__exec-';
-/**
- * Send a JSON-serialized message to the extension WebSocket if connected.
- * Centralizes the null check on state.extensionWs so callers don't repeat it.
- * Returns true if the message was sent, false if the extension is not connected.
- */
-const sendToExtension = (state, msg) => {
-    if (!state.extensionWs)
-        return false;
-    try {
-        state.extensionWs.send(JSON.stringify(msg));
-        return true;
-    }
-    catch (err) {
-        log.warn('Failed to send to extension:', err);
-        return false;
-    }
-};
-/**
- * Write a plugin's adapter IIFE to the extension's adapters/ directory.
- * The extension injects adapters via chrome.scripting.executeScript({ files: [...] })
- * using these files, bypassing page CSP restrictions.
- *
- * If a source map is provided, writes it alongside the adapter as {pluginName}.js.map
- * and rewrites the sourceMappingURL in the IIFE to reference the per-plugin filename
- * (prevents collisions when multiple plugins are loaded).
- */
-const writeAdapterFile = async (pluginName, iife, sourceMap) => {
-    const adaptersDir = getAdaptersDir();
-    const finalPath = join(adaptersDir, `${pluginName}.js`);
-    const tmpPath = join(adaptersDir, `${pluginName}.js.tmp`);
-    let content = iife;
-    if (sourceMap) {
-        // Rewrite sourceMappingURL to use the per-plugin filename
-        content = iife.replace(/\/\/# sourceMappingURL=adapter\.iife\.js\.map/, `//# sourceMappingURL=${pluginName}.js.map`);
-        // Write source map atomically
-        const mapFinalPath = join(adaptersDir, `${pluginName}.js.map`);
-        const mapTmpPath = join(adaptersDir, `${pluginName}.js.map.tmp`);
-        await Bun.write(mapTmpPath, sourceMap);
-        await rename(mapTmpPath, mapFinalPath);
-    }
-    await Bun.write(tmpPath, content);
-    await rename(tmpPath, finalPath);
-};
-/**
- * Remove stale adapter .js files from the adapters directory that do not
- * correspond to any plugin in the current set. Called from sendSyncFull
- * before writing new adapter files.
- */
-const cleanupStaleAdapterFiles = async (currentPluginNames) => {
-    const adaptersDir = getAdaptersDir();
-    let entries;
-    try {
-        entries = await readdir(adaptersDir);
-    }
-    catch {
-        // Directory may not exist yet on first run
-        return;
-    }
-    const staleFiles = entries.filter(f => {
-        if (f.endsWith('.js.tmp') || f.endsWith('.js.map.tmp'))
-            return false;
-        if (f.startsWith(EXEC_FILE_PREFIX))
-            return false; // Managed by cleanupStaleExecFiles
-        // Match adapter .js files
-        if (f.endsWith('.js')) {
-            const pluginName = f.slice(0, -3); // strip '.js'
-            return !currentPluginNames.has(pluginName);
-        }
-        // Match adapter .js.map source map files
-        if (f.endsWith('.js.map')) {
-            const pluginName = f.slice(0, -7); // strip '.js.map'
-            return !currentPluginNames.has(pluginName);
-        }
-        return false;
-    });
-    if (staleFiles.length === 0)
-        return;
-    const results = await Promise.allSettled(staleFiles.map(f => Bun.file(join(adaptersDir, f)).delete()));
-    let deleted = 0;
-    for (const [i, result] of results.entries()) {
-        if (result.status === 'rejected') {
-            const fileName = staleFiles[i] ?? 'unknown';
-            log.warn(`Failed to delete stale adapter file ${fileName}:`, result.reason);
-        }
-        else {
-            deleted++;
-        }
-    }
-    log.info(`Cleaned up ${deleted} stale adapter file(s)`);
-};
-/** Timeout for batch adapter file writes in sendSyncFull (10 seconds) */
-const ADAPTER_WRITE_TIMEOUT_MS = 10_000;
-/** Create a cancellable timeout promise for use with Promise.race */
-const timeoutRace = (value, ms) => {
-    let timerId;
-    const promise = new Promise(resolve => {
-        timerId = setTimeout(() => resolve(value), ms);
-    });
-    // timerId is assigned synchronously by the Promise executor
-    const cancel = () => clearTimeout(timerId);
-    return { promise, cancel };
-};
 /**
  * Send sync.full notification to extension on connect.
  * Writes all plugin adapter IIFEs to the extension's adapters/ directory,
@@ -136,7 +21,7 @@ const sendSyncFull = async (state) => {
     // Uses allSettled so a single plugin's write failure doesn't block the sync notification.
     // Races against a timeout so stalled writes don't hang hot reload indefinitely.
     const pluginList = Array.from(state.registry.plugins.values());
-    await ensureAdaptersDir();
+    await ensureAdaptersDir(state);
     // Remove stale adapter files from plugins that are no longer in the current set
     const currentPluginNames = new Set(pluginList.map(p => p.name));
     await cleanupStaleAdapterFiles(currentPluginNames);
@@ -156,24 +41,9 @@ const sendSyncFull = async (state) => {
         }
     }
     const plugins = pluginList.map(p => ({
-        name: p.name,
-        version: p.version,
-        displayName: p.displayName,
-        urlPatterns: p.urlPatterns,
-        trustTier: p.trustTier,
+        ...serializePluginForExtension(p, state),
         sourcePath: p.sourcePath,
         adapterHash: p.adapterHash,
-        ...(p.iconSvg ? { iconSvg: p.iconSvg } : {}),
-        ...(p.iconInactiveSvg ? { iconInactiveSvg: p.iconInactiveSvg } : {}),
-        tools: p.tools.map(t => ({
-            name: t.name,
-            displayName: t.displayName,
-            description: t.description,
-            icon: t.icon,
-            ...(t.iconSvg ? { iconSvg: t.iconSvg } : {}),
-            ...(t.iconInactiveSvg ? { iconInactiveSvg: t.iconInactiveSvg } : {}),
-            enabled: isToolEnabled(state, prefixedToolName(p.name, t.name)),
-        })),
     }));
     const sent = sendToExtension(state, {
         jsonrpc: '2.0',
@@ -227,7 +97,7 @@ const dispatchToExtension = (state, method, params, options) => {
         catch (err) {
             clearTimeout(timerId);
             state.pendingDispatches.delete(id);
-            reject(new Error(`WebSocket send failed: ${err instanceof Error ? err.message : String(err)}`));
+            reject(new Error(`WebSocket send failed: ${toErrorMessage(err)}`));
         }
     });
 };
@@ -296,51 +166,6 @@ const sendConfirmationRequest = (state, tool, domain, tabId, paramsPreview) => {
         }
     });
 };
-/**
- * Handle a confirmation.response from the extension.
- * Resolves the pending confirmation promise with the user's decision.
- * For 'allow_always', also adds a session permission rule.
- */
-const handleConfirmationResponse = (state, params) => {
-    if (!params)
-        return;
-    const id = params.id;
-    if (typeof id !== 'string')
-        return;
-    const decision = params.decision;
-    if (decision !== 'allow_once' && decision !== 'allow_always' && decision !== 'deny')
-        return;
-    const pending = state.pendingConfirmations.get(id);
-    if (!pending)
-        return;
-    clearTimeout(pending.timerId);
-    state.pendingConfirmations.delete(id);
-    // For allow_always, add a session permission rule based on the scope
-    if (decision === 'allow_always') {
-        const scope = typeof params.scope === 'string' ? params.scope : 'tool_domain';
-        const rule = { tool: pending.tool, domain: pending.domain, scope };
-        // Adjust rule fields based on scope
-        if (scope === 'tool_all') {
-            rule.domain = null;
-        }
-        else if (scope === 'domain_all') {
-            rule.tool = null;
-        }
-        state.sessionPermissions.push(rule);
-    }
-    pending.resolve(decision);
-};
-/**
- * Reject all pending confirmations. Called when the extension disconnects
- * to clean up any confirmation promises that can no longer be fulfilled.
- */
-const rejectAllPendingConfirmations = (state) => {
-    for (const [id, pending] of state.pendingConfirmations) {
-        clearTimeout(pending.timerId);
-        pending.reject(new Error('Extension disconnected — confirmation cancelled'));
-        state.pendingConfirmations.delete(id);
-    }
-};
 /**
  * Send plugin.update notification to extension with updated plugin metadata.
  * Writes the adapter IIFE to the extension's adapters/ directory first,
@@ -356,30 +181,15 @@ const sendPluginUpdate = async (state, pluginName, iife, sourceMap) => {
     const plugin = state.registry.plugins.get(pluginName);
     if (!plugin)
         return;
-    await ensureAdaptersDir();
+    await ensureAdaptersDir(state);
     await writeAdapterFile(pluginName, iife, sourceMap);
     const sent = sendToExtension(state, {
         jsonrpc: '2.0',
         method: 'plugin.update',
         params: {
-            name: plugin.name,
-            version: plugin.version,
-            displayName: plugin.displayName,
-            urlPatterns: plugin.urlPatterns,
-            trustTier: plugin.trustTier,
+            ...serializePluginForExtension(plugin, state),
             sourcePath: plugin.sourcePath,
             adapterHash: plugin.adapterHash,
-            ...(plugin.iconSvg ? { iconSvg: plugin.iconSvg } : {}),
-            ...(plugin.iconInactiveSvg ? { iconInactiveSvg: plugin.iconInactiveSvg } : {}),
-            tools: plugin.tools.map(t => ({
-                name: t.name,
-                displayName: t.displayName,
-                description: t.description,
-                icon: t.icon,
-                ...(t.iconSvg ? { iconSvg: t.iconSvg } : {}),
-                ...(t.iconInactiveSvg ? { iconInactiveSvg: t.iconInactiveSvg } : {}),
-                enabled: isToolEnabled(state, prefixedToolName(plugin.name, t.name)),
-            })),
         },
     });
     if (!sent)
@@ -426,8 +236,19 @@ const handleExtensionMessage = (state, text, callbacks, senderWs) => {
         clearTimeout(pending.timerId);
         log.debug('dispatch ← extension:', pending.label, 'id:', id, 'in', `${Date.now() - pending.startTs}ms`);
         if ('error' in parsed) {
-            const err = parsed.error;
-            const error = new DispatchError(err.message, err.code, err.data);
+            const rawErr = parsed.error;
+            const errObj = rawErr !== null && typeof rawErr === 'object' && !Array.isArray(rawErr)
+                ? rawErr
+                : {};
+            const errCode = typeof errObj.code === 'number' ? errObj.code : -32603;
+            const errMsg = typeof errObj.message === 'string' ? errObj.message : 'Unknown extension error';
+            const errData = errObj.data !== null &&
+                errObj.data !== undefined &&
+                typeof errObj.data === 'object' &&
+                !Array.isArray(errObj.data)
+                ? errObj.data
+                : undefined;
+            const error = new DispatchError(errMsg, errCode, errData);
             pending.reject(error);
         }
         else {
@@ -443,7 +264,7 @@ const handleExtensionMessage = (state, text, callbacks, senderWs) => {
         return;
     }
     const params = rawParams;
-    // Handle notifications/requests from extension
+    // Route to individual handlers in extension-handlers.ts
     if (method === 'tab.syncAll') {
         handleTabSyncAll(state, params);
         return;
@@ -452,7 +273,6 @@ const handleExtensionMessage = (state, text, callbacks, senderWs) => {
         handleTabStateChanged(state, params, id);
         return;
     }
-    // Handle config operations (requests with id from side panel, relayed through extension)
     if (method === 'config.getState' && id !== undefined) {
         handleConfigGetState(state, id);
         return;
@@ -465,6 +285,26 @@ const handleExtensionMessage = (state, text, callbacks, senderWs) => {
         handleConfigSetAllToolsEnabled(state, params, id, callbacks);
         return;
     }
+    if (method === 'plugin.search' && id !== undefined) {
+        void handlePluginSearch(state, params, id);
+        return;
+    }
+    if (method === 'plugin.install' && id !== undefined) {
+        void handlePluginInstall(state, params, id, callbacks);
+        return;
+    }
+    if (method === 'plugin.updateFromRegistry' && id !== undefined) {
+        void handlePluginUpdateFromRegistry(state, params, id, callbacks);
+        return;
+    }
+    if (method === 'plugin.remove' && id !== undefined) {
+        void handlePluginRemove(state, params, id, callbacks);
+        return;
+    }
+    if (method === 'plugin.checkUpdates' && id !== undefined) {
+        void handlePluginCheckUpdates(state, id);
+        return;
+    }
     if (method === 'tool.progress') {
         handleToolProgress(state, params);
         return;
@@ -479,11 +319,7 @@ const handleExtensionMessage = (state, text, callbacks, senderWs) => {
     }
     // Unrecognized method with an id — send JSON-RPC -32601 'Method not found'
     if (id !== undefined && method) {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32601, message: `Method not found: ${method}` },
-            id,
-        });
+        sendJsonRpcError(state, id, -32601, `Method not found: ${method}`);
         return;
     }
     // Unrecognized notification or malformed message
@@ -528,330 +364,6 @@ const isDispatchError = (err) => err !== null &&
     'code' in err &&
     'name' in err &&
     err.name === 'DispatchError';
-const parseTabMapping = (wire) => ({
-    state: wire.state === 'closed' || wire.state === 'unavailable' || wire.state === 'ready' ? wire.state : 'closed',
-    tabId: typeof wire.tabId === 'number' ? wire.tabId : null,
-    url: typeof wire.url === 'string' ? wire.url : null,
-});
-const handleTabSyncAll = (state, params) => {
-    if (!params)
-        return;
-    const tabSyncParams = params;
-    const tabs = tabSyncParams.tabs;
-    if (!tabs)
-        return;
-    state.tabMapping.clear();
-    for (const [pluginName, mapping] of Object.entries(tabs)) {
-        state.tabMapping.set(pluginName, parseTabMapping(mapping));
-    }
-    log.info(`tab.syncAll received — ${state.tabMapping.size} plugin(s) mapped`);
-};
-const handleTabStateChanged = (state, params, id) => {
-    const sendError = (message) => {
-        if (id !== undefined) {
-            sendToExtension(state, { jsonrpc: '2.0', error: { code: -32602, message }, id });
-        }
-        else {
-            log.warn(`tab.stateChanged: ${message}`);
-        }
-    };
-    if (!params) {
-        sendError('Missing params');
-        return;
-    }
-    const plugin = params.plugin;
-    if (typeof plugin !== 'string' || plugin.length === 0) {
-        sendError('Missing or invalid "plugin" field (expected non-empty string)');
-        return;
-    }
-    if (!state.registry.plugins.has(plugin)) {
-        sendError(`Unknown plugin: ${plugin}`);
-        return;
-    }
-    if (typeof params.state !== 'string') {
-        sendError('Missing or invalid "state" field (expected string)');
-        return;
-    }
-    if (params.state !== 'closed' && params.state !== 'unavailable' && params.state !== 'ready') {
-        sendError(`Invalid tab state: ${params.state} (expected closed, unavailable, or ready)`);
-        return;
-    }
-    const wire = {
-        state: params.state,
-        tabId: typeof params.tabId === 'number' ? params.tabId : null,
-        url: typeof params.url === 'string' ? params.url : null,
-    };
-    state.tabMapping.set(plugin, parseTabMapping(wire));
-    log.info(`tab.stateChanged: ${plugin} → ${wire.state ?? 'unknown'}`);
-};
-const handleConfigGetState = (state, id) => {
-    const plugins = Array.from(state.registry.plugins.values())
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map(p => {
-        const tabInfo = state.tabMapping.get(p.name);
-        return {
-            name: p.name,
-            displayName: p.displayName,
-            version: p.version,
-            trustTier: p.trustTier,
-            source: p.source,
-            tabState: tabInfo?.state ?? 'closed',
-            urlPatterns: p.urlPatterns,
-            ...(p.sdkVersion ? { sdkVersion: p.sdkVersion } : {}),
-            ...(p.iconSvg ? { iconSvg: p.iconSvg } : {}),
-            ...(p.iconInactiveSvg ? { iconInactiveSvg: p.iconInactiveSvg } : {}),
-            tools: p.tools.map(t => ({
-                name: t.name,
-                displayName: t.displayName,
-                description: t.description,
-                icon: t.icon,
-                ...(t.iconSvg ? { iconSvg: t.iconSvg } : {}),
-                ...(t.iconInactiveSvg ? { iconInactiveSvg: t.iconInactiveSvg } : {}),
-                enabled: isToolEnabled(state, prefixedToolName(p.name, t.name)),
-            })),
-        };
-    });
-    sendToExtension(state, {
-        jsonrpc: '2.0',
-        result: {
-            plugins,
-            failedPlugins: state.discoveryErrors.map(e => ({ specifier: e.specifier, error: e.error })),
-            outdatedPlugins: state.outdatedPlugins,
-        },
-        id,
-    });
-};
-const handleConfigSetToolEnabled = (state, params, id, callbacks) => {
-    if (!params) {
-        sendToExtension(state, { jsonrpc: '2.0', error: { code: -32602, message: 'Missing params' }, id });
-        return;
-    }
-    const toolEnabledParams = params;
-    const pluginName = toolEnabledParams.plugin;
-    const tool = toolEnabledParams.tool;
-    const enabled = toolEnabledParams.enabled;
-    if (typeof pluginName !== 'string' || typeof tool !== 'string' || typeof enabled !== 'boolean') {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32602, message: 'Invalid params: expected plugin (string), tool (string), enabled (boolean)' },
-            id,
-        });
-        return;
-    }
-    const plugin = state.registry.plugins.get(pluginName);
-    if (!plugin) {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32602, message: `Plugin not found: ${pluginName}` },
-            id,
-        });
-        return;
-    }
-    if (!plugin.tools.some(t => t.name === tool)) {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32602, message: `Tool not found: ${tool} in plugin ${pluginName}` },
-            id,
-        });
-        return;
-    }
-    const prefixed = prefixedToolName(pluginName, tool);
-    state.toolConfig[prefixed] = enabled;
-    callbacks.onToolConfigChanged();
-    callbacks.onToolConfigPersist();
-    sendToExtension(state, {
-        jsonrpc: '2.0',
-        result: { ok: true },
-        id,
-    });
-};
-const handleConfigSetAllToolsEnabled = (state, params, id, callbacks) => {
-    if (!params) {
-        sendToExtension(state, { jsonrpc: '2.0', error: { code: -32602, message: 'Missing params' }, id });
-        return;
-    }
-    const allToolsEnabledParams = params;
-    const pluginName = allToolsEnabledParams.plugin;
-    const enabled = allToolsEnabledParams.enabled;
-    if (typeof pluginName !== 'string' || typeof enabled !== 'boolean') {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32602, message: 'Invalid params: expected plugin (string), enabled (boolean)' },
-            id,
-        });
-        return;
-    }
-    const plugin = state.registry.plugins.get(pluginName);
-    if (!plugin) {
-        sendToExtension(state, {
-            jsonrpc: '2.0',
-            error: { code: -32602, message: `Plugin not found: ${pluginName}` },
-            id,
-        });
-        return;
-    }
-    for (const tool of plugin.tools) {
-        const prefixed = prefixedToolName(pluginName, tool.name);
-        state.toolConfig[prefixed] = enabled;
-    }
-    callbacks.onToolConfigChanged();
-    callbacks.onToolConfigPersist();
-    sendToExtension(state, {
-        jsonrpc: '2.0',
-        result: { ok: true },
-        id,
-    });
-};
-/**
- * Handle tool.progress notification from the extension.
- * Looks up the pending dispatch by dispatchId, invokes the onProgress callback
- * to emit an MCP ProgressNotification to the client, and resets the dispatch
- * timeout timer (the tool is alive). The timer reset is bounded by
- * MAX_DISPATCH_TIMEOUT_MS — if the dispatch has been running longer than the
- * absolute maximum, it is rejected immediately regardless of progress.
- */
-const handleToolProgress = (state, params) => {
-    if (!params)
-        return;
-    const dispatchId = params.dispatchId;
-    if (typeof dispatchId !== 'string')
-        return;
-    const progress = params.progress;
-    const total = params.total;
-    if (typeof progress !== 'number' || typeof total !== 'number')
-        return;
-    const message = typeof params.message === 'string' ? params.message : undefined;
-    const pending = state.pendingDispatches.get(dispatchId);
-    if (!pending)
-        return;
-    pending.lastProgressTs = Date.now();
-    // Forward the progress notification to the MCP client
-    if (pending.onProgress) {
-        try {
-            pending.onProgress(progress, total, message);
-        }
-        catch {
-            // Fire-and-forget — errors in the progress chain must not affect tool execution
-        }
-    }
-    // Reset the dispatch timeout — the tool is alive and making progress.
-    // Bounded by MAX_DISPATCH_TIMEOUT_MS from the dispatch start time.
-    clearTimeout(pending.timerId);
-    const elapsed = Date.now() - pending.startTs;
-    const remainingMax = MAX_DISPATCH_TIMEOUT_MS - elapsed;
-    if (remainingMax <= 0) {
-        // Absolute max exceeded — reject immediately
-        state.pendingDispatches.delete(dispatchId);
-        pending.reject(new Error(`Dispatch ${pending.label} exceeded absolute max timeout of ${MAX_DISPATCH_TIMEOUT_MS}ms`));
-        return;
-    }
-    const nextTimeout = Math.min(DISPATCH_TIMEOUT_MS, remainingMax);
-    pending.timerId = setTimeout(() => {
-        if (state.pendingDispatches.has(dispatchId)) {
-            state.pendingDispatches.delete(dispatchId);
-            pending.reject(new Error(`Dispatch ${pending.label} timed out after ${DISPATCH_TIMEOUT_MS}ms`));
-        }
-    }, nextTimeout);
-};
-/** Valid plugin log levels (matches MCP LoggingLevel subset used by the SDK) */
-const VALID_LOG_LEVELS = new Set(['debug', 'info', 'warning', 'error']);
-const handlePluginLog = (params, callbacks) => {
-    if (!params)
-        return;
-    const plugin = params.plugin;
-    const level = params.level;
-    const message = params.message;
-    if (typeof plugin !== 'string' || plugin.length === 0)
-        return;
-    if (typeof level !== 'string' || !VALID_LOG_LEVELS.has(level))
-        return;
-    if (typeof message !== 'string')
-        return;
-    const ts = typeof params.ts === 'string' ? params.ts : new Date().toISOString();
-    const entry = {
-        level,
-        plugin,
-        message,
-        data: params.data,
-        ts,
-    };
-    appendLog(plugin, entry);
-    callbacks.onPluginLog(entry);
-};
-// ---------------------------------------------------------------------------
-// Dynamic exec file helpers — write/delete/cleanup for browser_execute_script
-// ---------------------------------------------------------------------------
-/**
- * Write a dynamic exec script to the adapters/ directory.
- * Wraps the user's code in an IIFE that captures the result (sync or async)
- * into globalThis.__openTabs.__lastExecResult for the extension to read back.
- *
- * Returns the filename (relative to adapters/) for the extension to inject.
- */
-const writeExecFile = async (execId, code) => {
-    await ensureAdaptersDir();
-    const filename = `${EXEC_FILE_PREFIX}${execId}.js`;
-    const adaptersDir = getAdaptersDir();
-    const finalPath = join(adaptersDir, filename);
-    const tmpPath = join(adaptersDir, `${filename}.tmp`);
-    // Wrap user code to capture sync/async results and errors.
-    // The wrapper stores results at globalThis.__openTabs.__lastExecResult.
-    // The extension reads this value after injection and cleans it up.
-    //
-    // User code is passed as a JSON-escaped string literal to new Function(),
-    // preventing IIFE wrapper breakout attacks. The Function constructor
-    // parses the code in its own context — closing braces/parens in user
-    // code cannot break the wrapper syntax.
-    const wrapped = [
-        '(function() {',
-        '  var __ot = globalThis.__openTabs = globalThis.__openTabs || {};',
-        '  try {',
-        `    var __userFn = new Function(${JSON.stringify(code)});`,
-        '    var __r = __userFn();',
-        '    if (__r && typeof __r === "object" && typeof __r.then === "function") {',
-        '      __ot.__lastExecAsync = true;',
-        '      __r.then(function(v) { __ot.__lastExecResult = { value: v }; })',
-        '        .catch(function(e) { __ot.__lastExecResult = { error: e instanceof Error ? e.message : String(e) }; });',
-        '    } else {',
-        '      __ot.__lastExecResult = { value: __r };',
-        '    }',
-        '  } catch (e) {',
-        '    __ot.__lastExecResult = { error: e instanceof Error ? e.message : String(e) };',
-        '  }',
-        '})();',
-    ].join('\n');
-    await Bun.write(tmpPath, wrapped);
-    await rename(tmpPath, finalPath);
-    return filename;
-};
-/** Delete a dynamic exec script file. Fire-and-forget — logs on failure. */
-const deleteExecFile = async (filename) => {
-    try {
-        await Bun.file(join(getAdaptersDir(), filename)).delete();
-    }
-    catch {
-        log.warn(`Failed to delete exec file: ${filename}`);
-    }
-};
-/**
- * Remove stale __exec-*.js files from the adapters directory.
- * Called on server startup to clean up leftovers from crashed sessions.
- */
-const cleanupStaleExecFiles = async () => {
-    const adaptersDir = getAdaptersDir();
-    let entries;
-    try {
-        entries = await readdir(adaptersDir);
-    }
-    catch {
-        return;
-    }
-    const staleExecFiles = entries.filter(f => f.startsWith(EXEC_FILE_PREFIX) && (f.endsWith('.js') || f.endsWith('.js.tmp')));
-    if (staleExecFiles.length === 0)
-        return;
-    await Promise.allSettled(staleExecFiles.map(f => Bun.file(join(adaptersDir, f)).delete()));
-    log.info(`Cleaned up ${staleExecFiles.length} stale exec file(s)`);
-};
 /**
  * Send extension.reload JSON-RPC request to trigger chrome.runtime.reload()
  * in the connected extension. Used when the server detects that the managed