labgate 0.5.10 → 0.5.12

package/dist/lib/dataset-mcp.js

@@ -0,0 +1,809 @@
+"use strict";
+/**
+ * LabGate Dataset MCP Server
+ *
+ * A Model Context Protocol server that exposes dataset browsing and
+ * inspection tools to Claude Code. Runs as a standalone process using
+ * stdio transport.
+ *
+ * Usage: node dist/lib/dataset-mcp.js
+ *
+ * Reads dataset configuration from ~/.labgate/config.json.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePathWithinRoot = resolvePathWithinRoot;
+exports.main = main;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const config_js_1 = require("./config.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const zod_1 = require("zod");
+// ── Helpers ──────────────────────────────────────────────
+function resolveDatasetPath(ds) {
+    if (process.env.LABGATE_CONTAINER_MODE === '1') {
+        return `/datasets/${ds.name}`;
+    }
+    return ds.path.replace(/^~/, (0, os_1.homedir)());
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const val = bytes / Math.pow(1024, i);
+    return `${val.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+function clampInt(value, fallback, min, max) {
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function isPathInside(rootPath, targetPath) {
+    const rel = (0, path_1.relative)(rootPath, targetPath);
+    return rel === '' || (!rel.startsWith('..') && !(0, path_1.isAbsolute)(rel));
+}
+/**
+ * Resolve a user-provided path under a root directory and reject traversal.
+ * Returns null when the resolved path escapes the root.
+ *
+ * If the target exists, symlinks are resolved and containment is re-checked
+ * to prevent escaping via symlink hops.
+ */
+function resolvePathWithinRoot(root, userPath) {
+    const resolvedRoot = (0, path_1.resolve)(root);
+    const resolvedTarget = (0, path_1.resolve)(resolvedRoot, userPath || '.');
+    if (!isPathInside(resolvedRoot, resolvedTarget))
+        return null;
+    if ((0, fs_1.existsSync)(resolvedTarget)) {
+        try {
+            const canonicalRoot = (0, fs_1.existsSync)(resolvedRoot) ? (0, fs_1.realpathSync)(resolvedRoot) : resolvedRoot;
+            const canonicalTarget = (0, fs_1.realpathSync)(resolvedTarget);
+            if (!isPathInside(canonicalRoot, canonicalTarget))
+                return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return resolvedTarget;
+}
+function canAccess(path, mode) {
+    try {
+        (0, fs_1.accessSync)(path, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tailReadFile(filePath, maxLines) {
+    if (!(0, fs_1.existsSync)(filePath))
+        return '';
+    const st = (0, fs_1.statSync)(filePath);
+    const maxBytes = 1_048_576; // 1 MB
+    const readSize = Math.min(st.size, maxBytes);
+    if (readSize === 0)
+        return '';
+    const buf = Buffer.alloc(readSize);
+    let fd = null;
+    try {
+        fd = (0, fs_1.openSync)(filePath, 'r');
+        (0, fs_1.readSync)(fd, buf, 0, readSize, Math.max(0, st.size - readSize));
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                (0, fs_1.closeSync)(fd);
+            }
+            catch { /* best effort */ }
+        }
+    }
+    let text = buf.toString('utf-8');
+    if (st.size > readSize) {
+        const firstNewline = text.indexOf('\n');
+        if (firstNewline >= 0)
+            text = text.slice(firstNewline + 1);
+    }
+    const lines = text.split('\n');
+    return lines.slice(-maxLines).join('\n');
+}
+/** Recursively walk a directory up to a depth limit, collecting file info. */
+function walkDir(dir, maxDepth, currentDepth = 0) {
+    const results = [];
+    if (currentDepth > maxDepth)
+        return results;
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        // Skip hidden files at top level to reduce noise
+        if (entry.startsWith('.') && currentDepth === 0)
+            continue;
+        const fullPath = (0, path_1.join)(dir, entry);
+        try {
+            const st = (0, fs_1.statSync)(fullPath);
+            results.push({ path: fullPath, size: st.size, isDir: st.isDirectory() });
+            if (st.isDirectory() && currentDepth < maxDepth) {
+                results.push(...walkDir(fullPath, maxDepth, currentDepth + 1));
+            }
+        }
+        catch {
+            // Skip entries we can't stat (permission errors, etc.)
+        }
+    }
+    return results;
+}
+/** Glob-style matching (simple: supports * and ?) */
+function simpleMatch(pattern, text) {
+    const regex = new RegExp('^' +
+        pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.') +
+        '$', 'i');
+    return regex.test(text);
+}
+function datasetNameFromPath(path) {
+    return (0, path_1.basename)(path).replace(/[^a-zA-Z0-9._-]/g, '-');
+}
+function validDatasetName(name) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name);
+}
+function readRawConfig() {
+    const configPath = (0, config_js_1.getConfigPath)();
+    try {
+        const rawText = (0, fs_1.readFileSync)(configPath, 'utf-8');
+        const stripped = rawText
+            .split('\n')
+            .filter((line) => !line.trimStart().startsWith('//'))
+            .join('\n');
+        const rawConfig = JSON.parse(stripped);
+        if (!Array.isArray(rawConfig.datasets))
+            rawConfig.datasets = [];
+        return { configPath, rawConfig };
+    }
+    catch {
+        return { error: 'Could not read config file.' };
+    }
+}
+function writeRawConfig(configPath, rawConfig) {
+    try {
+        (0, config_js_1.ensurePrivateDir)((0, path_1.dirname)(configPath));
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(rawConfig, null, 2), 'utf-8');
+        (0, config_js_1.ensurePrivateFile)(configPath);
+        return { ok: true };
+    }
+    catch (err) {
+        return { error: `Failed to write config: ${err.message}` };
+    }
+}
+function findDatasetIndex(rawConfig, name) {
+    if (!Array.isArray(rawConfig.datasets))
+        return -1;
+    return rawConfig.datasets.findIndex((d) => d?.name && String(d.name).toLowerCase() === name.toLowerCase());
+}
+function findDatasetNameConflict(rawConfig, name, excludeIndex = -1) {
+    if (!Array.isArray(rawConfig.datasets))
+        return null;
+    return rawConfig.datasets.find((d, i) => i !== excludeIndex && d?.name && String(d.name).toLowerCase() === name.toLowerCase()) || null;
+}
+function findDatasetPathConflict(rawConfig, path, excludeIndex = -1) {
+    if (!Array.isArray(rawConfig.datasets))
+        return null;
+    const normalized = (0, path_1.resolve)(path.replace(/^~/, (0, os_1.homedir)()));
+    return rawConfig.datasets.find((d, i) => i !== excludeIndex && d?.path && (0, path_1.resolve)(String(d.path).replace(/^~/, (0, os_1.homedir)())) === normalized) || null;
+}
+function registeredSummary(ds) {
+    return `${ds.name} (${ds.mode}) at ${ds.path}`;
+}
+function parseAbsolutePath(inputPath) {
+    if (!inputPath || !inputPath.startsWith('/')) {
+        return { error: 'Path must be an absolute path starting with /.' };
+    }
+    return { resolved: inputPath.replace(/^~/, (0, os_1.homedir)()) };
+}
+function ensureDirectory(path) {
+    if (!(0, fs_1.existsSync)(path))
+        return { error: `Path does not exist: ${path}` };
+    const st = (0, fs_1.statSync)(path);
+    if (!st.isDirectory())
+        return { error: `Path is not a directory: ${path}` };
+    return { ok: true };
+}
+function asJson(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+    };
+}
+function asText(text) {
+    return {
+        content: [{ type: 'text', text }],
+    };
+}
+function asError(text) {
+    return {
+        content: [{ type: 'text', text }],
+        isError: true,
+    };
+}
+// ── MCP Server ───────────────────────────────────────────
+async function main() {
+    const server = new mcp_js_1.McpServer({
+        name: 'labgate-datasets',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+        instructions: 'LabGate Dataset tools. Use these tools to discover, browse, and inspect ' +
+            'datasets mounted in the LabGate sandbox. Datasets are mounted at /datasets/{name} ' +
+            'inside the container and are accessible on the host via their configured paths.',
+    });
+    // Helper to load fresh datasets from config each time
+    function getDatasets() {
+        try {
+            const config = (0, config_js_1.loadConfig)();
+            return config.datasets || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    // ── Tool: list_datasets ──────────────────────────────────
+    server.registerTool('list_datasets', {
+        title: 'List Datasets',
+        description: 'List all configured datasets with their names, paths, access modes, ' +
+            'descriptions, and basic stats (total size, file count).',
+        inputSchema: {},
+    }, async () => {
+        const datasets = getDatasets();
+        if (datasets.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No datasets configured.' }],
+            };
+        }
+        const summaries = datasets.map((ds) => {
+            const hostPath = resolveDatasetPath(ds);
+            const exists = (0, fs_1.existsSync)(hostPath);
+            let fileCount = 0;
+            let totalSize = 0;
+            if (exists) {
+                try {
+                    const entries = walkDir(hostPath, 1);
+                    const files = entries.filter((e) => !e.isDir);
+                    fileCount = files.length;
+                    totalSize = files.reduce((sum, f) => sum + f.size, 0);
+                }
+                catch { /* best effort */ }
+            }
+            return {
+                name: ds.name,
+                container_path: `/datasets/${ds.name}`,
+                host_path: hostPath,
+                mode: ds.mode,
+                description: ds.description || null,
+                exists,
+                file_count: fileCount,
+                total_size: formatBytes(totalSize),
+                total_size_bytes: totalSize,
+            };
+        });
+        return asJson(summaries);
+    });
+    // ── Tool: inspect_dataset ────────────────────────────────
+    server.registerTool('inspect_dataset', {
+        title: 'Inspect Dataset',
+        description: 'Browse the contents of a dataset directory. Returns a listing of files and ' +
+            'subdirectories with sizes. Use the path parameter to explore subdirectories.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Dataset name (as configured in LabGate)'),
+            path: zod_1.z.string().optional().describe('Relative path within the dataset to browse (default: root)'),
+            depth: zod_1.z.number().int().min(0).max(5).optional().default(1).describe('How many levels deep to list (0 = current dir only, max 5)'),
+        },
+    }, async ({ name, path: relPath, depth }) => {
+        const datasets = getDatasets();
+        const ds = datasets.find((d) => d.name === name);
+        if (!ds) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see available datasets.`);
+        }
+        const hostRoot = resolveDatasetPath(ds);
+        const targetDir = resolvePathWithinRoot(hostRoot, relPath);
+        if (!targetDir) {
+            return asError('Path traversal is not allowed.');
+        }
+        if (!(0, fs_1.existsSync)(targetDir)) {
+            return asError(`Path does not exist: ${relPath || '/'}`);
+        }
+        const safeDepth = clampInt(depth, 1, 0, 5);
+        const st = (0, fs_1.statSync)(targetDir);
+        if (!st.isDirectory()) {
+            // It's a file — return file info
+            return asJson({
+                type: 'file',
+                name: (0, path_1.basename)(targetDir),
+                size: formatBytes(st.size),
+                size_bytes: st.size,
+                modified: st.mtime.toISOString(),
+                extension: (0, path_1.extname)(targetDir),
+            });
+        }
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(targetDir);
+        }
+        catch (err) {
+            return asError(`Cannot read directory: ${err.message}`);
+        }
+        const items = entries
+            .sort()
+            .map((entry) => {
+            const fullPath = (0, path_1.join)(targetDir, entry);
+            try {
+                const est = (0, fs_1.statSync)(fullPath);
+                const item = {
+                    name: entry,
+                    type: est.isDirectory() ? 'directory' : 'file',
+                    size: formatBytes(est.size),
+                    size_bytes: est.size,
+                    modified: est.mtime.toISOString(),
+                };
+                if (!est.isDirectory()) {
+                    item.extension = (0, path_1.extname)(entry);
+                }
+                if (est.isDirectory() && safeDepth > 0) {
+                    try {
+                        const subEntries = (0, fs_1.readdirSync)(fullPath);
+                        item.child_count = subEntries.length;
+                    }
+                    catch { /* permission error */ }
+                }
+                return item;
+            }
+            catch {
+                return { name: entry, type: 'unknown', error: 'cannot stat' };
+            }
+        })
+            .slice(0, 200); // Cap at 200 entries
+        const browsePath = relPath || '/';
+        return asJson({
+            dataset: name,
+            container_path: `/datasets/${name}${relPath ? '/' + relPath : ''}`,
+            browsing: browsePath,
+            total_entries: entries.length,
+            shown: items.length,
+            items,
+        });
+    });
+    // ── Tool: search_dataset ─────────────────────────────────
+    server.registerTool('search_dataset', {
+        title: 'Search Dataset Files',
+        description: 'Search for files within a dataset by name pattern (glob-style: * and ? wildcards). ' +
+            'Returns matching files with paths and sizes.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Dataset name'),
+            pattern: zod_1.z.string().describe('Filename pattern to match (e.g., "*.csv", "sample_?.fastq.gz")'),
+            max_results: zod_1.z.number().int().min(1).max(500).optional().default(50).describe('Maximum results to return'),
+        },
+    }, async ({ name, pattern, max_results }) => {
+        const datasets = getDatasets();
+        const ds = datasets.find((d) => d.name === name);
+        if (!ds) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see available datasets.`);
+        }
+        const hostRoot = resolveDatasetPath(ds);
+        if (!(0, fs_1.existsSync)(hostRoot)) {
+            return asError(`Dataset path does not exist: ${hostRoot}`);
+        }
+        const safeMax = clampInt(max_results, 50, 1, 500);
+        const allFiles = walkDir(hostRoot, 10);
+        const matches = allFiles
+            .filter((f) => !f.isDir && simpleMatch(pattern, (0, path_1.basename)(f.path)))
+            .slice(0, safeMax)
+            .map((f) => ({
+            name: (0, path_1.basename)(f.path),
+            relative_path: f.path.slice(hostRoot.length + 1),
+            container_path: `/datasets/${ds.name}/${f.path.slice(hostRoot.length + 1)}`,
+            size: formatBytes(f.size),
+            size_bytes: f.size,
+        }));
+        if (matches.length === 0) {
+            return asText(`No files matching "${pattern}" found in dataset "${name}".`);
+        }
+        return asJson({
+            dataset: name,
+            pattern,
+            match_count: matches.length,
+            matches,
+        });
+    });
+    // ── Tool: get_dataset_summary ────────────────────────────
+    server.registerTool('get_dataset_summary', {
+        title: 'Dataset Summary Statistics',
+        description: 'Get summary statistics for a dataset: total size, file count, breakdown by ' +
+            'file extension, largest files, and directory structure overview.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Dataset name'),
+        },
+    }, async ({ name }) => {
+        const datasets = getDatasets();
+        const ds = datasets.find((d) => d.name === name);
+        if (!ds) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see available datasets.`);
+        }
+        const hostRoot = resolveDatasetPath(ds);
+        if (!(0, fs_1.existsSync)(hostRoot)) {
+            return asError(`Dataset path does not exist: ${hostRoot}`);
+        }
+        const allEntries = walkDir(hostRoot, 10);
+        const files = allEntries.filter((e) => !e.isDir);
+        const dirs = allEntries.filter((e) => e.isDir);
+        const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+        // Breakdown by extension
+        const extCounts = {};
+        for (const f of files) {
+            const ext = (0, path_1.extname)(f.path).toLowerCase() || '(no extension)';
+            if (!extCounts[ext])
+                extCounts[ext] = { count: 0, size: 0 };
+            extCounts[ext].count++;
+            extCounts[ext].size += f.size;
+        }
+        const byExtension = Object.entries(extCounts)
+            .sort((a, b) => b[1].size - a[1].size)
+            .slice(0, 20)
+            .map(([ext, info]) => ({
+            extension: ext,
+            count: info.count,
+            total_size: formatBytes(info.size),
+        }));
+        // Top 10 largest files
+        const largestFiles = files
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 10)
+            .map((f) => ({
+            name: (0, path_1.basename)(f.path),
+            relative_path: f.path.slice(hostRoot.length + 1),
+            size: formatBytes(f.size),
+        }));
+        // Top-level directory names
+        const topLevelDirs = dirs
+            .filter((d) => {
+            const rel = d.path.slice(hostRoot.length + 1);
+            return !rel.includes('/') && !rel.includes('\\');
+        })
+            .map((d) => (0, path_1.basename)(d.path))
+            .sort();
+        return asJson({
+            dataset: name,
+            container_path: `/datasets/${name}`,
+            host_path: hostRoot,
+            mode: ds.mode,
+            description: ds.description || null,
+            total_files: files.length,
+            total_directories: dirs.length,
+            total_size: formatBytes(totalSize),
+            total_size_bytes: totalSize,
+            by_extension: byExtension,
+            largest_files: largestFiles,
+            top_level_directories: topLevelDirs,
+        });
+    });
+    // ── Tool: read_dataset_file ──────────────────────────────
+    server.registerTool('read_dataset_file', {
+        title: 'Read Dataset File',
+        description: 'Read the contents of a text file within a dataset (last N lines). ' +
+            'Useful for previewing CSV headers, README files, config files, etc.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Dataset name'),
+            path: zod_1.z.string().describe('Relative path to the file within the dataset'),
+            tail_lines: zod_1.z.number().int().min(1).max(5000).optional().default(50).describe('Number of lines to read from the end of the file'),
+        },
+    }, async ({ name, path: relPath, tail_lines }) => {
+        const datasets = getDatasets();
+        const ds = datasets.find((d) => d.name === name);
+        if (!ds) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see available datasets.`);
+        }
+        const hostRoot = resolveDatasetPath(ds);
+        const filePath = resolvePathWithinRoot(hostRoot, relPath);
+        if (!filePath) {
+            return asError('Path traversal is not allowed.');
+        }
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return asError(`File not found: ${relPath}`);
+        }
+        const st = (0, fs_1.statSync)(filePath);
+        if (st.isDirectory()) {
+            return asError(`"${relPath}" is a directory. Use inspect_dataset to browse directories.`);
+        }
+        // Warn for likely binary files
+        const binaryExts = new Set([
+            '.gz', '.bz2', '.xz', '.zip', '.tar', '.bam', '.cram',
+            '.sra', '.hdf5', '.h5', '.png', '.jpg', '.jpeg', '.gif',
+            '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.pptx',
+            '.so', '.o', '.a', '.exe', '.dll', '.pyc',
+        ]);
+        const ext = (0, path_1.extname)(filePath).toLowerCase();
+        if (binaryExts.has(ext)) {
+            return asText(`File "${relPath}" appears to be a binary file (${ext}). ` +
+                `Size: ${formatBytes(st.size)}. Use inspect_dataset or get_dataset_summary instead.`);
+        }
+        const safeTailLines = clampInt(tail_lines, 50, 1, 5000);
+        const content = tailReadFile(filePath, safeTailLines);
+        if (!content) {
+            return asText(`File "${relPath}" is empty (${formatBytes(st.size)}).`);
+        }
+        return asText(`=== ${relPath} (last ${safeTailLines} lines, size: ${formatBytes(st.size)}) ===\n${content}`);
+    });
+    // ── Tool: validate_dataset ───────────────────────────────
+    server.registerTool('validate_dataset', {
+        title: 'Validate Dataset Registration',
+        description: 'Validate that a host dataset path and name are usable before registering. ' +
+            'Checks existence, directory type, permissions, and name/path conflicts.',
+        inputSchema: {
+            path: zod_1.z.string().describe('Absolute host path to the dataset directory'),
+            name: zod_1.z.string().optional().describe('Proposed dataset name (optional, auto-derived from path)'),
+            mode: zod_1.z.enum(['ro', 'rw']).optional().default('ro').describe('Requested mount mode'),
+        },
+    }, async ({ path: dsPath, name, mode }) => {
+        const parsedPath = parseAbsolutePath(dsPath);
+        const requestedMode = mode || 'ro';
+        if ('error' in parsedPath) {
+            return asError(parsedPath.error);
+        }
+        const resolvedPath = parsedPath.resolved;
+        const proposedName = (name?.trim() ? name.trim() : datasetNameFromPath(resolvedPath)).replace(/[^a-zA-Z0-9._-]/g, '-');
+        const loaded = readRawConfig();
+        if ('error' in loaded)
+            return asError(loaded.error);
+        const exists = (0, fs_1.existsSync)(resolvedPath);
+        const isDirectory = exists ? (0, fs_1.statSync)(resolvedPath).isDirectory() : false;
+        const readable = exists ? canAccess(resolvedPath, fs_1.constants.R_OK) : false;
+        const writable = exists ? canAccess(resolvedPath, fs_1.constants.W_OK) : false;
+        const requiresWrite = requestedMode === 'rw';
+        const nameValid = validDatasetName(proposedName);
+        const nameConflict = findDatasetNameConflict(loaded.rawConfig, proposedName);
+        const pathConflict = findDatasetPathConflict(loaded.rawConfig, resolvedPath);
+        const valid = (exists &&
+            isDirectory &&
+            readable &&
+            (!requiresWrite || writable) &&
+            nameValid &&
+            !nameConflict &&
+            !pathConflict);
+        let sampleEntries = 0;
+        let sampleFiles = 0;
+        let sampleSizeBytes = 0;
+        if (exists && isDirectory && readable) {
+            const walked = walkDir(resolvedPath, 1);
+            sampleEntries = walked.length;
+            const files = walked.filter((e) => !e.isDir);
+            sampleFiles = files.length;
+            sampleSizeBytes = files.reduce((sum, f) => sum + f.size, 0);
+        }
+        return asJson({
+            valid,
+            path_input: dsPath,
+            resolved_path: resolvedPath,
+            requested_name: proposedName,
+            name_valid: nameValid,
+            mode_requested: requestedMode,
+            required_access: requiresWrite ? 'read/write' : 'read',
+            exists,
+            is_directory: isDirectory,
+            readable,
+            writable,
+            name_conflict: nameConflict ? registeredSummary(nameConflict) : null,
+            path_conflict: pathConflict ? registeredSummary(pathConflict) : null,
+            container_mount: `/datasets/${proposedName}`,
+            sample_entries_depth_1: sampleEntries,
+            sample_files_depth_1: sampleFiles,
+            sample_size_depth_1: formatBytes(sampleSizeBytes),
+            sample_size_bytes_depth_1: sampleSizeBytes,
+        });
+    });
+    // ── Tool: register_dataset ────────────────────────────
+    server.registerTool('register_dataset', {
+        title: 'Register Dataset',
+        description: 'Register a new dataset by adding a host directory to the LabGate config. ' +
+            'The dataset will be mounted at /datasets/{name} in the next container session. ' +
+            'Name is auto-derived from the directory basename if not provided.',
+        inputSchema: {
+            path: zod_1.z.string().describe('Absolute host path to the dataset directory'),
+            name: zod_1.z.string().optional().describe('Name for the dataset (used as mount point). Auto-derived from path if omitted.'),
+            mode: zod_1.z.enum(['ro', 'rw']).optional().default('ro').describe('Access mode: ro (read-only, default) or rw (read-write)'),
+            description: zod_1.z.string().optional().describe('Brief description of the dataset contents'),
+        },
+    }, async ({ path: dsPath, name, mode, description }) => {
+        const parsedPath = parseAbsolutePath(dsPath);
+        if ('error' in parsedPath)
+            return asError(parsedPath.error);
+        const resolvedPath = parsedPath.resolved;
+        const dirCheck = ensureDirectory(resolvedPath);
+        if ('error' in dirCheck)
+            return asError(dirCheck.error);
+        const dsName = (name?.trim() ? name.trim() : datasetNameFromPath(resolvedPath)).replace(/[^a-zA-Z0-9._-]/g, '-');
+        if (!validDatasetName(dsName)) {
+            return asError(`Invalid dataset name: "${dsName}". Use alphanumerics, hyphens, dots, underscores. Must start with alphanumeric.`);
+        }
+        const requestedMode = mode || 'ro';
+        if (!canAccess(resolvedPath, fs_1.constants.R_OK)) {
+            return asError(`Path is not readable: ${resolvedPath}`);
+        }
+        if (requestedMode === 'rw' && !canAccess(resolvedPath, fs_1.constants.W_OK)) {
+            return asError(`Path is not writable for rw mode: ${resolvedPath}`);
+        }
+        const loaded = readRawConfig();
+        if ('error' in loaded)
+            return asError(loaded.error);
+        const existingByName = findDatasetNameConflict(loaded.rawConfig, dsName);
+        if (existingByName) {
+            return asError(`Dataset name already exists: ${registeredSummary(existingByName)}`);
+        }
+        const existingByPath = findDatasetPathConflict(loaded.rawConfig, resolvedPath);
+        if (existingByPath) {
+            return asError(`Dataset path already exists: ${registeredSummary(existingByPath)}`);
+        }
+        const newDs = { path: dsPath, name: dsName, mode: requestedMode };
+        const desc = description?.trim();
+        if (desc)
+            newDs.description = desc;
+        loaded.rawConfig.datasets.push(newDs);
+        const writeResult = writeRawConfig(loaded.configPath, loaded.rawConfig);
+        if ('error' in writeResult)
+            return asError(writeResult.error);
+        return asText(`Dataset "${dsName}" registered.\n` +
+            `  Path: ${dsPath}\n` +
+            `  Mode: ${newDs.mode}\n` +
+            `  Container mount: /datasets/${dsName}\n` +
+            (desc ? `  Description: ${desc}\n` : '') +
+            `\nNote: The dataset will be mounted in the next container session (restart required).`);
+    });
+    // ── Tool: update_dataset ────────────────────────────────
+    server.registerTool('update_dataset', {
+        title: 'Update Dataset',
+        description: 'Update an existing dataset registration (name, path, mode, description). ' +
+            'Changes apply on next session restart.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Current dataset name to update'),
+            new_name: zod_1.z.string().optional().describe('New dataset name'),
+            path: zod_1.z.string().optional().describe('New absolute host path'),
+            mode: zod_1.z.enum(['ro', 'rw']).optional().describe('New mode'),
+            description: zod_1.z.string().optional().describe('New description (empty string clears)'),
+            clear_description: zod_1.z.boolean().optional().default(false).describe('Clear description explicitly'),
+        },
+    }, async ({ name, new_name, path: nextPath, mode: nextMode, description: nextDescription, clear_description }) => {
+        if (!name || !name.trim())
+            return asError('Dataset name is required.');
+        const requestedMutation = new_name !== undefined ||
+            nextPath !== undefined ||
+            nextMode !== undefined ||
+            nextDescription !== undefined ||
+            clear_description;
+        if (!requestedMutation)
+            return asError('No update fields provided.');
+        const loaded = readRawConfig();
+        if ('error' in loaded)
+            return asError(loaded.error);
+        const idx = findDatasetIndex(loaded.rawConfig, name.trim());
+        if (idx < 0) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see registered datasets.`);
+        }
+        const current = loaded.rawConfig.datasets[idx];
+        const before = {
+            name: current.name,
+            path: current.path,
+            mode: current.mode,
+            description: current.description,
+        };
+        let updatedPath = current.path;
+        let updatedPathResolved = (0, path_1.resolve)(String(current.path).replace(/^~/, (0, os_1.homedir)()));
+        if (nextPath !== undefined) {
+            const parsed = parseAbsolutePath(nextPath);
+            if ('error' in parsed)
+                return asError(parsed.error);
+            const dirCheck = ensureDirectory(parsed.resolved);
+            if ('error' in dirCheck)
+                return asError(dirCheck.error);
+            updatedPath = nextPath;
+            updatedPathResolved = (0, path_1.resolve)(parsed.resolved);
+        }
+        const updatedName = (new_name?.trim() ? new_name.trim() : current.name).replace(/[^a-zA-Z0-9._-]/g, '-');
+        if (!validDatasetName(updatedName)) {
+            return asError(`Invalid dataset name: "${updatedName}". Use alphanumerics, hyphens, dots, underscores. Must start with alphanumeric.`);
+        }
+        const updatedMode = nextMode || current.mode || 'ro';
+        if (!canAccess(updatedPathResolved, fs_1.constants.R_OK)) {
+            return asError(`Path is not readable: ${updatedPathResolved}`);
+        }
+        if (updatedMode === 'rw' && !canAccess(updatedPathResolved, fs_1.constants.W_OK)) {
+            return asError(`Path is not writable for rw mode: ${updatedPathResolved}`);
+        }
+        const nameConflict = findDatasetNameConflict(loaded.rawConfig, updatedName, idx);
+        if (nameConflict) {
+            return asError(`Dataset name already exists: ${registeredSummary(nameConflict)}`);
+        }
+        const pathConflict = findDatasetPathConflict(loaded.rawConfig, updatedPathResolved, idx);
+        if (pathConflict) {
+            return asError(`Dataset path already exists: ${registeredSummary(pathConflict)}`);
+        }
+        let updatedDescription = current.description;
+        if (clear_description) {
+            updatedDescription = undefined;
+        }
+        else if (nextDescription !== undefined) {
+            const trimmed = nextDescription.trim();
+            updatedDescription = trimmed || undefined;
+        }
+        const next = {
+            name: updatedName,
+            path: updatedPath,
+            mode: updatedMode,
+        };
+        if (updatedDescription)
+            next.description = updatedDescription;
+        const changed = before.name !== next.name ||
+            before.path !== next.path ||
+            before.mode !== next.mode ||
+            (before.description || undefined) !== (next.description || undefined);
+        if (!changed) {
+            return asText(`No changes for dataset "${name}".`);
+        }
+        loaded.rawConfig.datasets[idx] = next;
+        const writeResult = writeRawConfig(loaded.configPath, loaded.rawConfig);
+        if ('error' in writeResult)
+            return asError(writeResult.error);
+        return asText(`Dataset "${before.name}" updated.\n` +
+            `  Before: ${before.path} (${before.mode})\n` +
+            `  After:  ${next.path} (${next.mode}) as "${next.name}"\n` +
+            `  Description: ${next.description || '(none)'}\n` +
+            `\nNote: Changes take effect in the next container session (restart required).`);
+    });
+    // ── Tool: unregister_dataset ─────────────────────────
+    server.registerTool('unregister_dataset', {
+        title: 'Unregister Dataset',
+        description: 'Remove a dataset from the LabGate config. The mount will be removed on the next container session.',
+        inputSchema: {
+            name: zod_1.z.string().describe('Name of the dataset to remove'),
+        },
+    }, async ({ name }) => {
+        if (!name || !name.trim()) {
+            return asError('Dataset name is required.');
+        }
+        const loaded = readRawConfig();
+        if ('error' in loaded)
+            return asError(loaded.error);
+        const idx = findDatasetIndex(loaded.rawConfig, name.trim());
+        if (idx < 0) {
+            return asError(`Dataset "${name}" not found. Use list_datasets to see registered datasets.`);
+        }
+        const removed = loaded.rawConfig.datasets.splice(idx, 1)[0];
+        const writeResult = writeRawConfig(loaded.configPath, loaded.rawConfig);
+        if ('error' in writeResult)
+            return asError(writeResult.error);
+        return asText(`Dataset "${removed.name}" removed.\n` +
+            `  Was: ${removed.path} (${removed.mode})\n` +
+            `\nNote: The mount will be removed on the next container session (restart required).`);
+    });
+    // ── Connect and start ──────────────────────────────────
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    process.on('SIGINT', () => process.exit(0));
+    process.on('SIGTERM', () => process.exit(0));
+}
+function isDirectRun() {
+    const argv1 = process.argv[1] || '';
+    return /(?:^|\/|\\)dataset-mcp(?:\.bundle)?(?:\.(?:js|mjs))?$/.test(argv1);
+}
+if (isDirectRun()) {
+    main().catch((err) => {
+        console.error('Dataset MCP server error:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=dataset-mcp.js.map