labgate 0.5.28 → 0.5.29

package/dist/lib/ui.js

@@ -58,6 +58,7 @@ const FONTS_DIR = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', 'ge
 const XTERM_CSS_PATH = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', '@xterm', 'xterm', 'css', 'xterm.css');
 const XTERM_JS_PATH = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', '@xterm', 'xterm', 'lib', 'xterm.js');
 const XTERM_FIT_JS_PATH = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', '@xterm', 'addon-fit', 'lib', 'addon-fit.js');
+const XTERM_WEB_LINKS_JS_PATH = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', '@xterm', 'addon-web-links', 'lib', 'addon-web-links.js');
 const WRITE_TOKEN_PLACEHOLDER = '__LABGATE_WRITE_TOKEN__';
 const UI_WRITE_TOKEN = (0, crypto_1.randomBytes)(24).toString('hex');
 const UI_AUTH_COOKIE = 'labgate_ui_token';
@@ -65,10 +66,25 @@ const UI_SHORT_LINK_PREFIX = '/s/';
 const DASHBOARD_LINK_FILE = '.labgate-dashboard-url';
 const LABGATE_INSTRUCTION_START = '<!-- LABGATE_SESSION_INSTRUCTION_START -->';
 const LABGATE_INSTRUCTION_END = '<!-- LABGATE_SESSION_INSTRUCTION_END -->';
+const IRIS_SAMPLE_DATASET_NAME = 'flowers-iris';
+const IRIS_SAMPLE_SOURCE_URL = 'https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv';
+const IRIS_SAMPLE_README = '# Iris Flowers Dataset (Sample)\n' +
+    '\n' +
+    'Source: https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv\n' +
+    '\n' +
+    'This dataset is a small sample for testing LabGate dataset registration.\n' +
+    'Rows: 150 iris flower measurements across three classes.\n';
+function resolveIrisSampleSourceUrl() {
+    const override = (process.env.LABGATE_IRIS_SAMPLE_SOURCE_URL || '').trim();
+    if (/^https?:\/\//i.test(override))
+        return override;
+    return IRIS_SAMPLE_SOURCE_URL;
+}
 // ── SLURM module state (initialised in startUI when slurm.enabled) ──
 let slurmDB = null;
 let slurmPoller = null;
 let resultsStore = null;
+const REQUIRED_SLURM_COMMANDS = ['sbatch', 'squeue', 'sacct', 'scancel'];
 const webTerminalBridges = new Map();
 function getResultsStore() {
     if (!resultsStore) {
@@ -76,6 +92,50 @@ function getResultsStore() {
     }
     return resultsStore;
 }
+function hasCommandInPath(command) {
+    const pathValue = (process.env.PATH || '').trim();
+    if (!pathValue)
+        return false;
+    const isWindows = (0, os_1.platform)() === 'win32';
+    const directories = pathValue.split(path_1.delimiter).filter(Boolean);
+    const hasExplicitExtension = /\.[^/\\]+$/.test(command);
+    const windowsExtensions = isWindows
+        ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+            .split(';')
+            .map((ext) => ext.trim().toLowerCase())
+            .filter(Boolean)
+        : [''];
+    for (const dir of directories) {
+        const candidates = isWindows
+            ? (hasExplicitExtension ? [command] : windowsExtensions.map((ext) => `${command}${ext}`))
+            : [command];
+        for (const candidate of candidates) {
+            const fullPath = (0, path_1.join)(dir, candidate);
+            if (!(0, fs_1.existsSync)(fullPath))
+                continue;
+            try {
+                const st = (0, fs_1.statSync)(fullPath);
+                if (!st.isFile())
+                    continue;
+                if (isWindows)
+                    return true;
+                (0, fs_1.accessSync)(fullPath, fs_1.constants.X_OK);
+                return true;
+            }
+            catch {
+                // Continue scanning PATH entries.
+            }
+        }
+    }
+    return false;
+}
+function getSlurmRuntimeStatus() {
+    const missingCommands = REQUIRED_SLURM_COMMANDS.filter((command) => !hasCommandInPath(command));
+    return {
+        available: missingCommands.length === 0,
+        missingCommands,
+    };
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -88,6 +148,103 @@ function json(res, data, status = 200) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
 }
+function normalizeEmailCandidate(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = value.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i);
+    if (!match)
+        return null;
+    return match[0].toLowerCase();
+}
+function deepFindEmail(value, depth = 0) {
+    if (depth > 6 || value === null || value === undefined)
+        return null;
+    const direct = normalizeEmailCandidate(value);
+    if (direct)
+        return direct;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = deepFindEmail(item, depth + 1);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (typeof value !== 'object')
+        return null;
+    const record = value;
+    const keys = Object.keys(record);
+    for (const key of keys) {
+        if (!/email|mail/i.test(key))
+            continue;
+        const found = deepFindEmail(record[key], depth + 1);
+        if (found)
+            return found;
+    }
+    for (const key of keys) {
+        const found = deepFindEmail(record[key], depth + 1);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function deepFindAccessToken(value, depth = 0) {
+    if (depth > 6 || value === null || value === undefined)
+        return '';
+    if (typeof value === 'string') {
+        const token = value.trim();
+        return token.length >= 20 ? token : '';
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = deepFindAccessToken(item, depth + 1);
+            if (found)
+                return found;
+        }
+        return '';
+    }
+    if (typeof value !== 'object')
+        return '';
+    const record = value;
+    const keys = Object.keys(record);
+    for (const key of keys) {
+        if (!/access.?token|token/i.test(key))
+            continue;
+        const found = deepFindAccessToken(record[key], depth + 1);
+        if (found)
+            return found;
+    }
+    return '';
+}
+function readClaudeCredentialSnapshot() {
+    const sandboxHome = (0, config_js_1.getSandboxHome)();
+    const credentialPaths = [
+        (0, path_1.join)(sandboxHome, '.claude', '.credentials.json'),
+        (0, path_1.join)(sandboxHome, '.claude', 'credentials.json'),
+    ];
+    for (const credPath of credentialPaths) {
+        if (!(0, fs_1.existsSync)(credPath))
+            continue;
+        try {
+            const parsed = JSON.parse((0, fs_1.readFileSync)(credPath, 'utf-8'));
+            const nestedOauth = parsed.claudeAiOauth ?? parsed.oauth ?? null;
+            const token = (typeof nestedOauth?.accessToken === 'string' && nestedOauth.accessToken.trim()) ||
+                (typeof parsed.accessToken === 'string' && parsed.accessToken.trim()) ||
+                deepFindAccessToken(parsed);
+            if (!token)
+                continue;
+            const email = deepFindEmail(nestedOauth?.email) ||
+                deepFindEmail(nestedOauth?.user) ||
+                deepFindEmail(nestedOauth?.profile) ||
+                deepFindEmail(parsed);
+            return { loggedIn: true, email: email || null };
+        }
+        catch {
+            // Ignore malformed credential files and keep searching.
+        }
+    }
+    return { loggedIn: false, email: null };
+}
 function getHeaderValue(req, name) {
     const value = req.headers[name.toLowerCase()];
     if (Array.isArray(value))
@@ -176,6 +333,39 @@ function clearDashboardLink(expectedUrl) {
         // Best effort cleanup.
     }
 }
+function supportsTerminalHyperlinks() {
+    if (!(process.stderr.isTTY ?? false))
+        return false;
+    if (process.env.LABGATE_UI_HYPERLINKS === '0')
+        return false;
+    if ((process.env.TERM || '').toLowerCase() === 'dumb')
+        return false;
+    return true;
+}
+function formatTerminalHyperlink(url) {
+    if (!supportsTerminalHyperlinks())
+        return url;
+    const safe = url.replace(/[\u001b\u0007]/g, '');
+    return `\u001b]8;;${safe}\u0007${url}\u001b]8;;\u0007`;
+}
+function shouldAutoOpenUiBrowser(standalone) {
+    if (!standalone)
+        return false;
+    if (process.env.LABGATE_UI_AUTO_OPEN === '0')
+        return false;
+    if (process.env.SSH_CONNECTION || process.env.SSH_TTY)
+        return false;
+    if (!(process.stdout.isTTY ?? false) && !(process.stderr.isTTY ?? false))
+        return false;
+    return (0, os_1.platform)() === 'darwin';
+}
+function autoOpenUiBrowser(url) {
+    (0, child_process_1.execFile)('open', [url], (err) => {
+        if (!err)
+            return;
+        log.warn('Could not auto-open browser. Use the Settings URL above.');
+    });
+}
 function serveFontFile(url, res) {
     // Only allow specific font files from the geist package
     const match = url.match(/^\/fonts\/([\w-]+\.woff2)$/);
@@ -378,6 +568,12 @@ function serveHTML(res) {
 function handleGetConfig(_req, res) {
     const effective = (0, config_js_1.loadEffectiveConfig)();
     const response = { ...effective.config };
+    const slurmRuntime = getSlurmRuntimeStatus();
+    response._slurm = {
+        available: slurmRuntime.available,
+        missing_commands: slurmRuntime.missingCommands,
+        required_commands: [...REQUIRED_SLURM_COMMANDS],
+    };
     // Attach enterprise metadata so the frontend knows which fields to lock
     if (effective.enterprise) {
         response._enterprise = {
@@ -420,7 +616,8 @@ async function handlePostConfig(req, res) {
             if (effective.lockedFields.has('audit.log_dir') && incoming.audit?.log_dir !== orig.audit.log_dir) {
                 violations.push('audit.log_dir');
             }
-            if (effective.lockedFields.has('slurm.enabled') && incoming.slurm?.enabled !== orig.slurm.enabled) {
+            const incomingSlurmEnabled = incoming.slurm?.enabled ?? orig.slurm.enabled;
+            if (effective.lockedFields.has('slurm.enabled') && incomingSlurmEnabled !== orig.slurm.enabled) {
                 violations.push('slurm.enabled');
             }
             if (violations.length > 0) {
@@ -1551,6 +1748,16 @@ function handleGetSecurity(_req, res) {
         },
     });
 }
+function handleGetClaudeAuthStatus(_req, res) {
+    const auth = readClaudeCredentialSnapshot();
+    json(res, {
+        ok: true,
+        provider: 'claude',
+        loggedIn: auth.loggedIn,
+        email: auth.email,
+        checkedAt: new Date().toISOString(),
+    });
+}
 async function handleStopSession(req, res) {
     try {
         const body = await readBody(req);
@@ -1758,7 +1965,12 @@ async function handlePostWebTerminalStart(req, res) {
 }
 async function handleGetWebTerminalSessions(res) {
     const records = (0, web_terminal_js_1.listWebTerminalRecords)();
+    const localNode = (0, os_1.hostname)();
     for (const record of records) {
+        // Shared home directories may contain records from other nodes.
+        // Only mutate runtime status for sessions that belong to this node.
+        if (record.node !== localNode)
+            continue;
         const alive = await (0, web_terminal_js_1.hasTmuxSession)(record.tmuxSession);
         if (alive && record.status !== 'running') {
             (0, web_terminal_js_1.updateWebTerminalRecordStatus)(record.id, { status: 'running', exitCode: null, error: null });
@@ -1791,6 +2003,10 @@ async function handlePostWebTerminalStop(req, res) {
             json(res, { ok: false, error: 'Terminal session not found' }, 404);
             return;
         }
+        if (record.node !== (0, os_1.hostname)()) {
+            json(res, { ok: false, error: `Terminal session is on a different node (${record.node})` }, 400);
+            return;
+        }
         try {
             await (0, web_terminal_js_1.killTmuxSession)(record.tmuxSession);
         }
@@ -1845,6 +2061,43 @@ async function handleValidatePath(req, res) {
         json(res, { valid: false, error: err.message ?? String(err) }, 400);
     }
 }
+// ── Directory browse helper ─────────────────────────────
+async function handleBrowseDir(req, res) {
+    try {
+        const body = await readBody(req);
+        const { path: rawPath } = JSON.parse(body);
+        const resolved = (rawPath && typeof rawPath === 'string' ? rawPath : '~').replace(/^~/, (0, os_1.homedir)());
+        if (!(0, fs_1.existsSync)(resolved) || !(0, fs_1.statSync)(resolved).isDirectory()) {
+            json(res, { ok: false, error: 'Not a directory', path: resolved });
+            return;
+        }
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(resolved);
+        }
+        catch {
+            json(res, { ok: false, error: 'Cannot read directory', path: resolved });
+            return;
+        }
+        const dirs = [];
+        for (const entry of entries) {
+            if (entry.startsWith('.'))
+                continue; // skip dotfiles
+            const full = (0, path_1.join)(resolved, entry);
+            try {
+                if ((0, fs_1.statSync)(full).isDirectory()) {
+                    dirs.push({ name: entry, path: full });
+                }
+            }
+            catch { /* skip inaccessible */ }
+        }
+        dirs.sort((a, b) => a.name.localeCompare(b.name));
+        json(res, { ok: true, path: resolved, dirs });
+    }
+    catch (err) {
+        json(res, { ok: false, error: err.message ?? String(err) }, 400);
+    }
+}
 // ── Dataset stats helpers ───────────────────────────────
 function formatBytesUI(bytes) {
     if (bytes === 0)
@@ -1968,6 +2221,129 @@ async function handlePostDatasetScan(req, res) {
         json(res, { ok: false, error: err.message ?? String(err) }, 500);
     }
 }
+async function handlePostDatasetExampleInstall(req, res) {
+    try {
+        const body = await readBody(req);
+        let parsed = {};
+        if (body.trim()) {
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                json(res, { ok: false, error: 'Invalid JSON body' }, 400);
+                return;
+            }
+        }
+        const requestedNameRaw = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+        const datasetName = requestedNameRaw || IRIS_SAMPLE_DATASET_NAME;
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(datasetName)) {
+            json(res, {
+                ok: false,
+                error: 'Invalid dataset name. Use alphanumerics, hyphens, dots, underscores.',
+            }, 400);
+            return;
+        }
+        const datasetMode = parsed.mode === 'rw' ? 'rw' : 'ro';
+        const sourceUrl = resolveIrisSampleSourceUrl();
+        const configPath = (0, config_js_1.getConfigPath)();
+        let obj = {};
+        if ((0, fs_1.existsSync)(configPath)) {
+            const rawText = (0, fs_1.readFileSync)(configPath, 'utf-8');
+            const stripped = rawText
+                .split('\n')
+                .filter((line) => !line.trimStart().startsWith('//'))
+                .join('\n');
+            try {
+                obj = JSON.parse(stripped);
+            }
+            catch {
+                obj = {};
+            }
+        }
+        const datasets = Array.isArray(obj.datasets) ? obj.datasets : [];
+        const byNameConflict = datasets.find((d) => {
+            const n = typeof d.name === 'string' ? d.name : '';
+            return n.toLowerCase() === datasetName.toLowerCase();
+        });
+        if (byNameConflict) {
+            json(res, { ok: false, error: `Dataset "${datasetName}" is already registered.` }, 409);
+            return;
+        }
+        const datasetDir = (0, path_1.join)(config_js_1.LABGATE_DIR, 'datasets', datasetName);
+        const byPathConflict = datasets.find((d) => {
+            if (typeof d.path !== 'string')
+                return false;
+            return (0, path_1.resolve)(d.path.replace(/^~/, (0, os_1.homedir)())) === (0, path_1.resolve)(datasetDir);
+        });
+        if (byPathConflict) {
+            json(res, { ok: false, error: `Dataset path is already registered: ${datasetDir}` }, 409);
+            return;
+        }
+        const ctrl = new AbortController();
+        const timeout = setTimeout(() => ctrl.abort(), 20_000);
+        let csvText = '';
+        try {
+            const download = await fetch(sourceUrl, { signal: ctrl.signal });
+            if (!download.ok) {
+                json(res, { ok: false, error: `Failed to download sample dataset (HTTP ${download.status}).` }, 502);
+                return;
+            }
+            csvText = await download.text();
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (!csvText.trim()) {
+            json(res, { ok: false, error: 'Downloaded sample dataset is empty.' }, 502);
+            return;
+        }
+        if (csvText.length > 5_000_000) {
+            json(res, { ok: false, error: 'Downloaded sample dataset is unexpectedly large.' }, 502);
+            return;
+        }
+        (0, fs_1.mkdirSync)(datasetDir, { recursive: true, mode: config_js_1.PRIVATE_DIR_MODE });
+        const csvPath = (0, path_1.join)(datasetDir, 'iris.csv');
+        const readmePath = (0, path_1.join)(datasetDir, 'README.md');
+        (0, fs_1.writeFileSync)(csvPath, csvText, { encoding: 'utf-8', mode: config_js_1.PRIVATE_FILE_MODE });
+        (0, fs_1.writeFileSync)(readmePath, IRIS_SAMPLE_README, { encoding: 'utf-8', mode: config_js_1.PRIVATE_FILE_MODE });
+        const totalSize = (0, fs_1.statSync)(csvPath).size + (0, fs_1.statSync)(readmePath).size;
+        const lineCount = csvText
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .length;
+        const rowCount = Math.max(0, lineCount - 1);
+        const entry = {
+            path: datasetDir,
+            name: datasetName,
+            mode: datasetMode,
+            description: `Iris flower measurements sample dataset (${rowCount} rows).`,
+            stats: {
+                file_count: 2,
+                total_size: totalSize,
+                total_size_formatted: formatBytesUI(totalSize),
+                scanned_at: new Date().toISOString(),
+            },
+        };
+        datasets.push(entry);
+        obj.datasets = datasets;
+        (0, fs_1.writeFileSync)(configPath, JSON.stringify(obj, null, 2) + '\n', { encoding: 'utf-8', mode: config_js_1.PRIVATE_FILE_MODE });
+        (0, config_js_1.ensurePrivateFile)(configPath);
+        json(res, {
+            ok: true,
+            dataset: entry,
+            downloaded_from: sourceUrl,
+            files: ['iris.csv', 'README.md'],
+        }, 201);
+    }
+    catch (err) {
+        if (err?.name === 'AbortError') {
+            json(res, { ok: false, error: 'Timed out downloading sample dataset.' }, 504);
+            return;
+        }
+        json(res, { ok: false, error: err?.message ?? String(err) }, 500);
+    }
+}
 function handleGetLogs(_req, res) {
     const config = (0, config_js_1.loadConfig)();
     if (!config.audit.enabled) {
@@ -3288,12 +3664,18 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/api/validate-path' && method === 'POST') {
                 await handleValidatePath(req, res);
             }
+            else if (pathname === '/api/browse-dir' && method === 'POST') {
+                await handleBrowseDir(req, res);
+            }
             else if (pathname === '/api/dataset-stats' && method === 'GET') {
                 handleGetDatasetStats(req, res);
             }
             else if (pathname === '/api/dataset-scan' && method === 'POST') {
                 await handlePostDatasetScan(req, res);
             }
+            else if (pathname === '/api/dataset-example/install' && method === 'POST') {
+                await handlePostDatasetExampleInstall(req, res);
+            }
             else if (/^\/api\/sessions\/[^/]+\/instructions$/.test(pathname) && method === 'GET') {
                 handleGetSessionInstructions(pathname, reqUrl, res);
             }
@@ -3306,6 +3688,9 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/api/security' && method === 'GET') {
                 handleGetSecurity(req, res);
             }
+            else if (pathname === '/api/claude/auth' && method === 'GET') {
+                handleGetClaudeAuthStatus(req, res);
+            }
             else if (pathname === '/api/results' && method === 'GET') {
                 handleGetResults(reqUrl, res);
             }
@@ -3395,6 +3780,9 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/vendor/xterm/addon-fit.js' && method === 'GET') {
                 serveVendorAsset(res, XTERM_FIT_JS_PATH, 'application/javascript; charset=utf-8');
             }
+            else if (pathname === '/vendor/xterm/addon-web-links.js' && method === 'GET') {
+                serveVendorAsset(res, XTERM_WEB_LINKS_JS_PATH, 'application/javascript; charset=utf-8');
+            }
             else {
                 if (pathname.startsWith('/api/')) {
                     json(res, { ok: false, error: 'Not found' }, 404);
@@ -3472,13 +3860,16 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
         if (useTcp) {
             const actualPort = server.address()?.port ?? listenPort;
             dashboardQuickLink = `http://localhost:${actualPort}${UI_SHORT_LINK_PREFIX}${uiShortCode}`;
-            log.step(`Settings: ${dashboardQuickLink}`);
+            log.step(`Settings: ${formatTerminalHyperlink(dashboardQuickLink)}`);
             try {
                 writeDashboardLink(dashboardQuickLink);
             }
             catch {
                 // Best effort: statusline can still fall back to LABGATE_DASHBOARD_URL/default URL.
             }
+            if (shouldAutoOpenUiBrowser(standalone)) {
+                autoOpenUiBrowser(dashboardQuickLink);
+            }
         }
         else {
             try {