nebula-notebook 0.1.0

package/node-server/dist/notebook/operation-router.js

@@ -0,0 +1,641 @@
+"use strict";
+/**
+ * Notebook Operation Router
+ *
+ * Routes notebook operations to either:
+ * 1. Connected UI via WebSocket (real-time collaboration)
+ * 2. Headless notebook manager (file-based when no UI)
+ *
+ * From the agent's (MCP) perspective, operations look identical regardless of mode.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationRouter = exports.OperationRouter = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const ws_1 = require("ws");
+const AGENT_LOCK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const UI_STALE_TIMEOUT_MS = 45 * 1000; // 45 seconds
+function normalizeNotebookPath(notebookPath) {
+    // IMPORTANT: This must match how the kernel service normalizes file paths.
+    // If the UI registers `~/foo.ipynb` but the kernel associates the session
+    // with `/home/user/foo.ipynb`, `hasUI()` would return false and background
+    // tasks (like output persistence) can incorrectly write the file and trigger
+    // spurious conflict dialogs.
+    return path.resolve(notebookPath.replace(/^~/, os.homedir()));
+}
+class OperationRouter {
+    uiConnections = new Map();
+    headlessHandler = null;
+    operationTimeout = 30000; // 30 seconds
+    agentLocks = new Map(); // path -> lock
+    setHeadlessHandler(handler) {
+        this.headlessHandler = handler;
+    }
+    /**
+     * Register a UI connection for a notebook path.
+     */
+    async registerUI(websocket, notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        // Close existing connection if any
+        if (this.uiConnections.has(normalizedPath)) {
+            const oldConn = this.uiConnections.get(normalizedPath);
+            if (oldConn.websocket !== websocket) {
+                for (const [, request] of oldConn.pendingRequests) {
+                    clearTimeout(request.timeoutId);
+                    request.reject(new Error('Connection replaced'));
+                }
+                // Ensure the old connection doesn't later unregister the new one.
+                try {
+                    oldConn.websocket.close(1000, 'Connection replaced');
+                }
+                catch {
+                    // Ignore close errors from already-closed sockets.
+                }
+            }
+        }
+        this.uiConnections.set(normalizedPath, {
+            websocket,
+            notebookPath: normalizedPath,
+            pendingRequests: new Map(),
+            lastActivityAt: Date.now(),
+        });
+        console.log(`[OperationRouter] UI registered for: ${normalizedPath}`);
+    }
+    /**
+     * Unregister a UI connection.
+     */
+    unregisterUI(websocket, notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        if (this.uiConnections.has(normalizedPath)) {
+            const conn = this.uiConnections.get(normalizedPath);
+            // If we replaced the UI connection and the old one closes later, ignore it.
+            if (conn.websocket !== websocket) {
+                return;
+            }
+            for (const [, request] of conn.pendingRequests) {
+                clearTimeout(request.timeoutId);
+                request.reject(new Error('UI disconnected'));
+            }
+            this.uiConnections.delete(normalizedPath);
+            console.log(`[OperationRouter] UI unregistered for: ${normalizedPath}`);
+        }
+    }
+    notifyKernelChanged(notebookPath, payload) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const conn = this.getResponsiveUIConnection(normalizedPath);
+        if (!conn) {
+            return;
+        }
+        try {
+            conn.websocket.send(JSON.stringify({
+                type: 'kernelChanged',
+                kernelName: payload.kernelName,
+                serverId: payload.serverId ?? null,
+            }));
+        }
+        catch (err) {
+            console.warn(`[OperationRouter] Failed to notify UI about kernel change for ${normalizedPath}:`, err);
+        }
+    }
+    /**
+     * Check if a UI is connected for the notebook.
+     */
+    hasUI(notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        return this.getResponsiveUIConnection(normalizedPath) !== null;
+    }
+    /**
+     * Record UI WebSocket activity so stale connections stop intercepting operations.
+     */
+    markUIActivity(websocket, notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const conn = this.uiConnections.get(normalizedPath);
+        if (!conn || conn.websocket !== websocket) {
+            return;
+        }
+        conn.lastActivityAt = Date.now();
+    }
+    /**
+     * Start an agent session with locking.
+     * Returns success if lock acquired, error if already locked by another agent.
+     */
+    startAgentSession(notebookPath, agentId, metadata) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        try {
+            const stat = fs.statSync(normalizedPath);
+            if (!stat.isFile()) {
+                return { success: false, error: `Notebook not found: ${normalizedPath}` };
+            }
+        }
+        catch {
+            return { success: false, error: `Notebook not found: ${normalizedPath}` };
+        }
+        // Clean up expired locks first
+        this.cleanupExpiredLocks();
+        const existingLock = this.agentLocks.get(normalizedPath);
+        if (existingLock) {
+            if (existingLock.agentId === agentId) {
+                // Same agent re-acquiring lock - refresh timeout
+                existingLock.expiresAt = Date.now() + AGENT_LOCK_TIMEOUT_MS;
+                console.log(`[OperationRouter] Agent session refreshed for: ${normalizedPath} (agent: ${agentId})`);
+                return { success: true, lock: existingLock };
+            }
+            else {
+                // Different agent has the lock
+                const lockedBy = existingLock.clientName || existingLock.agentId;
+                console.log(`[OperationRouter] Agent session BLOCKED for: ${normalizedPath} (requested by: ${agentId}, held by: ${lockedBy})`);
+                return {
+                    success: false,
+                    error: `Notebook is locked by ${lockedBy}. Lock expires in ${Math.ceil((existingLock.expiresAt - Date.now()) / 1000)}s.`,
+                    lock: existingLock,
+                };
+            }
+        }
+        // Acquire new lock
+        const now = Date.now();
+        const newLock = {
+            agentId,
+            clientName: metadata?.clientName,
+            clientVersion: metadata?.clientVersion,
+            expiresAt: now + AGENT_LOCK_TIMEOUT_MS,
+            notebookPath: normalizedPath,
+            lockedAt: now,
+        };
+        this.agentLocks.set(normalizedPath, newLock);
+        console.log(`[OperationRouter] Agent session started for: ${normalizedPath} (agent: ${agentId}, client: ${metadata?.clientName || 'unknown'})`);
+        return { success: true, lock: newLock };
+    }
+    /**
+     * End an agent session and release the lock.
+     * Only the lock holder can release the lock.
+     */
+    endAgentSession(notebookPath, agentId) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const existingLock = this.agentLocks.get(normalizedPath);
+        if (!existingLock) {
+            // No lock exists - that's fine
+            return { success: true };
+        }
+        if (existingLock.agentId !== agentId) {
+            console.log(`[OperationRouter] Agent session end REJECTED for: ${normalizedPath} (requested by: ${agentId}, held by: ${existingLock.agentId})`);
+            return {
+                success: false,
+                error: 'Cannot release lock held by another agent'
+            };
+        }
+        this.agentLocks.delete(normalizedPath);
+        console.log(`[OperationRouter] Agent session ended for: ${normalizedPath} (agent: ${agentId})`);
+        return { success: true };
+    }
+    /**
+     * Check if a notebook is in an agent session.
+     */
+    isAgentSession(notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const lock = this.agentLocks.get(normalizedPath);
+        return lock !== undefined && lock.expiresAt > Date.now();
+    }
+    /**
+     * Get the agent ID holding the lock, if any.
+     */
+    getAgentLock(notebookPath) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const lock = this.agentLocks.get(normalizedPath);
+        if (lock && lock.expiresAt > Date.now()) {
+            return lock;
+        }
+        return null;
+    }
+    /**
+     * Refresh lock timeout for an agent operation.
+     */
+    refreshAgentLock(notebookPath, agentId) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const lock = this.agentLocks.get(normalizedPath);
+        if (lock && lock.agentId === agentId) {
+            lock.expiresAt = Date.now() + AGENT_LOCK_TIMEOUT_MS;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clean up expired locks.
+     */
+    cleanupExpiredLocks() {
+        const now = Date.now();
+        for (const [path, lock] of this.agentLocks) {
+            if (lock.expiresAt <= now) {
+                console.log(`[OperationRouter] Agent lock expired for: ${path} (agent: ${lock.agentId})`);
+                this.agentLocks.delete(path);
+            }
+        }
+    }
+    /**
+     * Get the first available UI connection (for operations that can use any UI).
+     */
+    getAnyUIConnection() {
+        for (const [uiPath, conn] of this.uiConnections) {
+            if (this.isUIConnectionResponsive(conn)) {
+                return { path: uiPath, connection: conn };
+            }
+        }
+        return null;
+    }
+    isUIConnectionResponsive(conn) {
+        return conn.websocket.readyState === ws_1.WebSocket.OPEN && (Date.now() - conn.lastActivityAt) <= UI_STALE_TIMEOUT_MS;
+    }
+    getResponsiveUIConnection(notebookPath) {
+        const conn = this.uiConnections.get(notebookPath);
+        if (!conn) {
+            return null;
+        }
+        if (!this.isUIConnectionResponsive(conn)) {
+            return null;
+        }
+        return conn;
+    }
+    /**
+     * Apply a notebook operation.
+     */
+    async applyOperation(operation) {
+        const notebookPath = operation.notebookPath || '';
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        const opType = operation.type;
+        const agentId = operation.agentId;
+        // For createNotebook, route to ANY connected UI (not path-specific)
+        // This allows the UI to open the new notebook in a new tab
+        const isCreateNotebook = opType === 'createNotebook';
+        const anyUI = isCreateNotebook ? this.getAnyUIConnection() : null;
+        const hasUI = isCreateNotebook ? (anyUI !== null) : (this.getResponsiveUIConnection(normalizedPath) !== null);
+        const backend = hasUI ? 'ui' : 'headless';
+        // Clean up expired locks
+        this.cleanupExpiredLocks();
+        const lock = this.agentLocks.get(normalizedPath);
+        const isLocked = lock !== undefined && lock.expiresAt > Date.now();
+        console.log(`[OperationRouter] applyOperation:`);
+        console.log(`  op_type: ${opType}`);
+        console.log(`  notebook_path: ${notebookPath}`);
+        console.log(`  normalized_path: ${normalizedPath}`);
+        console.log(`  registered_uis: ${Array.from(this.uiConnections.keys())}`);
+        console.log(`  has_ui: ${hasUI}`);
+        console.log(`  is_locked: ${isLocked}${lock ? ` (by: ${lock.agentId})` : ''}`);
+        console.log(`  request_agent_id: ${agentId || '(none)'}`);
+        // Handle startAgentSession/endAgentSession at router level (before forwarding to UI)
+        // This ensures server-side lock is always managed regardless of UI connection
+        if (opType === 'startAgentSession') {
+            const reqAgentId = operation.agentId || 'unknown';
+            const clientName = operation.clientName;
+            const clientVersion = operation.clientVersion;
+            const lastSessionTimestamp = operation.lastSessionTimestamp;
+            const result = this.startAgentSession(notebookPath, reqAgentId, { clientName, clientVersion });
+            // Also forward to UI for UI state update (badge display)
+            if (result.success && hasUI) {
+                console.log(`  -> Lock acquired, forwarding to UI for badge update`);
+                await this.forwardToUI(normalizedPath, operation);
+            }
+            // If lastSessionTimestamp provided and we have headless handler, return changes since then
+            let updatesSince;
+            if (result.success && lastSessionTimestamp !== undefined && this.headlessHandler) {
+                updatesSince = this.headlessHandler.getUpdatesSince(normalizedPath, lastSessionTimestamp);
+                console.log(`  -> Returning ${updatesSince.length} updates since ${new Date(lastSessionTimestamp).toISOString()}`);
+            }
+            return { ...result, backend, updatesSince };
+        }
+        if (opType === 'endAgentSession') {
+            const reqAgentId = operation.agentId || 'unknown';
+            const result = this.endAgentSession(notebookPath, reqAgentId);
+            // Also forward to UI for UI state update (remove badge)
+            if (result.success && hasUI) {
+                console.log(`  -> Lock released, forwarding to UI for badge update`);
+                await this.forwardToUI(normalizedPath, operation);
+            }
+            return { ...result, backend };
+        }
+        // Enforce agent session for write operations
+        const readOnlyOps = new Set(['readCell', 'readCellOutput', 'searchCells', 'readNotebook', 'getUpdatesSince']);
+        const sessionOps = new Set(['startAgentSession', 'endAgentSession']);
+        const creationOps = new Set(['createNotebook']); // Operations that create files (don't require session)
+        const isWrite = !readOnlyOps.has(opType) && !sessionOps.has(opType) && !creationOps.has(opType);
+        if (isWrite) {
+            if (!isLocked) {
+                console.log(`  -> BLOCKED: Write requires active agent session`);
+                return {
+                    success: false,
+                    error: 'Agent session required for write operations. Call startAgentSession first.',
+                    backend,
+                };
+            }
+            if (!agentId) {
+                console.log(`  -> BLOCKED: Missing agentId for write operation`);
+                return {
+                    success: false,
+                    error: 'Agent session required for write operations (missing agentId).',
+                    backend,
+                };
+            }
+            if (lock && lock.agentId !== agentId) {
+                console.log(`  -> BLOCKED: Operation blocked by agent lock`);
+                return {
+                    success: false,
+                    error: `Notebook is locked by another agent (${lock.agentId}). Lock expires in ${Math.ceil((lock.expiresAt - Date.now()) / 1000)}s.`,
+                    backend,
+                };
+            }
+        }
+        // Refresh lock timeout if this agent holds it
+        if (lock && agentId && lock.agentId === agentId) {
+            lock.expiresAt = Date.now() + AGENT_LOCK_TIMEOUT_MS;
+        }
+        if (hasUI) {
+            // For createNotebook, use any available UI connection
+            const uiPath = isCreateNotebook && anyUI ? anyUI.path : normalizedPath;
+            console.log(`  -> Routing to UI (via ${uiPath})`);
+            const result = await this.forwardToUI(uiPath, operation);
+            return { ...result, backend: 'ui' };
+        }
+        else {
+            console.log(`  -> Routing to HEADLESS`);
+            const result = await this.applyHeadless(operation);
+            return { ...result, backend: 'headless' };
+        }
+    }
+    async forwardToUI(notebookPath, operation) {
+        const conn = this.getResponsiveUIConnection(notebookPath);
+        if (!conn) {
+            return {
+                success: false,
+                error: 'UI connection is no longer responsive',
+            };
+        }
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        // Calculate timeout based on operation type
+        const opType = operation.type;
+        let timeout = this.operationTimeout;
+        if (opType === 'executeCell') {
+            const maxWait = (operation.maxWait ?? operation.max_wait ?? 10);
+            timeout = (maxWait + 5) * 1000;
+        }
+        else if (opType === 'readCellOutput') {
+            const maxWait = (operation.maxWait ?? operation.max_wait ?? 0);
+            timeout = Math.max(this.operationTimeout, (maxWait + 5) * 1000);
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                conn.pendingRequests.delete(requestId);
+                // For executeCell, timeout means the cell is still running - return busy status, not error
+                if (opType === 'executeCell') {
+                    resolve({
+                        success: true,
+                        executionStatus: 'busy',
+                        // Pass through the original cellId/cellIndex from the operation for polling
+                        cellId: operation.cellId,
+                        cellIndex: operation.cellIndex,
+                        outputs: [],
+                        message: `Cell still executing after ${timeout / 1000}s. Use read_output with max_wait to poll for results.`,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: `Operation timed out after ${timeout / 1000}s`,
+                    });
+                }
+            }, timeout);
+            conn.pendingRequests.set(requestId, { resolve, reject, timeoutId });
+            // Send operation to UI
+            const message = {
+                type: 'operation',
+                operation,
+                requestId,
+            };
+            try {
+                conn.websocket.send(JSON.stringify(message));
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                conn.pendingRequests.delete(requestId);
+                resolve({
+                    success: false,
+                    error: `Failed to forward operation to UI: ${err}`,
+                });
+            }
+        });
+    }
+    /**
+     * Handle operation response from UI.
+     */
+    handleUIResponse(notebookPath, response) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        if (!this.getResponsiveUIConnection(normalizedPath)) {
+            console.log(`[OperationRouter] Received response for unknown notebook: ${notebookPath}`);
+            return;
+        }
+        const conn = this.getResponsiveUIConnection(normalizedPath);
+        conn.lastActivityAt = Date.now();
+        const requestId = response.requestId;
+        if (requestId && conn.pendingRequests.has(requestId)) {
+            const request = conn.pendingRequests.get(requestId);
+            clearTimeout(request.timeoutId);
+            conn.pendingRequests.delete(requestId);
+            const result = response.result || { success: false, error: 'No result in response' };
+            request.resolve(result);
+        }
+    }
+    async applyHeadless(operation) {
+        if (!this.headlessHandler) {
+            return {
+                success: false,
+                error: 'Headless manager not configured',
+            };
+        }
+        return await this.headlessHandler.applyOperation(operation);
+    }
+    /**
+     * Read notebook state.
+     */
+    async readNotebook(notebookPath, includeOutputs = true, maxLines, maxChars, maxLinesError, maxCharsError) {
+        const normalizedPath = normalizeNotebookPath(notebookPath);
+        if (this.getResponsiveUIConnection(normalizedPath)) {
+            const result = await this.readFromUI(normalizedPath);
+            if (result.success) {
+                const truncated = this.applyOutputTruncation(result, includeOutputs, maxLines, maxChars, maxLinesError, maxCharsError);
+                if (!truncated.backend) {
+                    truncated.backend = 'ui';
+                }
+                return truncated;
+            }
+            if (!result.backend) {
+                result.backend = 'ui';
+            }
+            return result;
+        }
+        else {
+            const result = await this.readFromFile(notebookPath, includeOutputs, maxLines, maxChars, maxLinesError, maxCharsError);
+            if (!result.backend) {
+                result.backend = 'headless';
+            }
+            return result;
+        }
+    }
+    async readFromUI(notebookPath) {
+        const conn = this.getResponsiveUIConnection(notebookPath);
+        if (!conn) {
+            return this.readFromFile(notebookPath);
+        }
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                conn.pendingRequests.delete(requestId);
+                console.log(`[OperationRouter] UI read timeout, falling back to file`);
+                this.readFromFile(notebookPath).then(resolve);
+            }, this.operationTimeout);
+            conn.pendingRequests.set(requestId, {
+                resolve,
+                reject: (err) => resolve({ success: false, error: String(err) }),
+                timeoutId,
+            });
+            const message = {
+                type: 'readNotebook',
+                requestId,
+            };
+            try {
+                conn.websocket.send(JSON.stringify(message));
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                conn.pendingRequests.delete(requestId);
+                resolve({
+                    success: false,
+                    error: `Failed to read from UI: ${err}`,
+                    backend: 'ui',
+                });
+            }
+        });
+    }
+    async readFromFile(notebookPath, includeOutputs = true, maxLines, maxChars, maxLinesError, maxCharsError) {
+        if (!this.headlessHandler) {
+            return {
+                success: false,
+                error: 'Headless manager not configured',
+                backend: 'headless',
+            };
+        }
+        const result = await this.headlessHandler.readNotebook(notebookPath, includeOutputs, maxLines, maxChars, maxLinesError, maxCharsError);
+        if (!result.backend) {
+            result.backend = 'headless';
+        }
+        return result;
+    }
+    applyOutputTruncation(result, includeOutputs, maxLines, maxChars, maxLinesError, maxCharsError) {
+        if (!result.success || !result.data) {
+            return result;
+        }
+        const data = result.data;
+        const cells = data.cells || [];
+        if (!includeOutputs) {
+            data.cells = cells.map((cell) => ({ ...cell, outputs: [] }));
+            return result;
+        }
+        // Apply truncation defaults
+        const effectiveMaxLines = maxLines ?? 100;
+        const effectiveMaxChars = maxChars ?? 10000;
+        const effectiveMaxLinesError = maxLinesError ?? 200;
+        const effectiveMaxCharsError = maxCharsError ?? 20000;
+        data.cells = cells.map((cell) => {
+            const c = cell;
+            const outputs = c.outputs || [];
+            return {
+                ...c,
+                outputs: outputs.map((output) => {
+                    const o = output;
+                    const outputType = o.type || 'stdout';
+                    const content = o.content || '';
+                    if (outputType === 'image' || outputType === 'html' || outputType === 'display_data') {
+                        return { ...o, is_binary: outputType === 'image' };
+                    }
+                    const linesLimit = outputType === 'error' ? effectiveMaxLinesError : effectiveMaxLines;
+                    const charsLimit = outputType === 'error' ? effectiveMaxCharsError : effectiveMaxChars;
+                    const lines = content.split('\n');
+                    const totalLines = lines.length;
+                    const totalChars = content.length;
+                    // Match Python's truncation logic exactly
+                    let truncated = false;
+                    let truncationReason = null;
+                    const resultLines = [];
+                    let charCount = 0;
+                    const startLine = 0;
+                    let endLine = 0;
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        const newCharCount = charCount + line.length + (i > 0 ? 1 : 0); // +1 for newline
+                        if (i >= linesLimit) {
+                            truncated = true;
+                            truncationReason = 'lines';
+                            break;
+                        }
+                        if (newCharCount > charsLimit && i > 0) { // Always include at least 1 line
+                            truncated = true;
+                            truncationReason = 'chars';
+                            break;
+                        }
+                        resultLines.push(line);
+                        charCount = newCharCount;
+                        endLine = startLine + i + 1;
+                    }
+                    const truncatedContent = resultLines.join('\n');
+                    return {
+                        type: outputType,
+                        content: truncatedContent,
+                        truncated,
+                        truncation_reason: truncationReason,
+                        total_lines: totalLines,
+                        total_chars: totalChars,
+                        returned_range: {
+                            start_line: startLine,
+                            end_line: endLine,
+                            char_count: truncatedContent.length,
+                        },
+                    };
+                }),
+            };
+        });
+        return result;
+    }
+}
+exports.OperationRouter = OperationRouter;
+// Global router instance
+exports.operationRouter = new OperationRouter();