labgate 0.5.33 → 0.5.34

package/dist/lib/ui.js

@@ -60,6 +60,7 @@ const explorer_store_js_1 = require("./explorer-store.js");
 const log = __importStar(require("./log.js"));
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const HTML_PATH = (0, path_1.resolve)(__dirname, '..', 'lib', 'ui.html');
+const PACKAGE_JSON_PATH = (0, path_1.resolve)(__dirname, '..', '..', 'package.json');
 const FONTS_DIR = (0, path_1.resolve)(__dirname, '..', '..', 'node_modules', 'geist', 'dist', 'fonts');
 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');
@@ -79,6 +80,12 @@ const PODMAN_SETUP_MAX_BUFFER = 16 * 1024 * 1024;
 const EXPLORER_TSP_TEMPLATE_DIR = (0, path_1.resolve)(__dirname, '..', '..', 'templates', 'tsp-lab');
 const EXPLORER_TSP_TEMPLATE_SOURCE_REPO = (0, path_1.join)((0, config_js_1.getExplorerRootDir)(), 'templates', 'tsp-lab-source');
 const EXPLORER_ARTIFACT_READ_MAX_BYTES = 2 * 1024 * 1024;
+const UI_VERSION_NPM_PACKAGE = 'labgate';
+const UI_VERSION_CHECK_TIMEOUT_MS = 8_000;
+const UI_VERSION_CHECK_MAX_BUFFER = 256 * 1024;
+const UI_VERSION_CACHE_TTL_MS = 5 * 60 * 1000;
+const UI_SELF_UPDATE_TIMEOUT_MS = 20 * 60 * 1000;
+const UI_SELF_UPDATE_MAX_BUFFER = 16 * 1024 * 1024;
 const IRIS_SAMPLE_README = '# Iris Flowers Dataset (Sample)\n' +
     '\n' +
     'Source: https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv\n' +
@@ -118,6 +125,18 @@ const CLAUDE_HEADLESS_STDERR_LIMIT = 12_000;
 const webTerminalInitJobs = new Map();
 const webTerminalImagePullLocks = new Map();
 const webTerminalAgentPrepLocks = new Map();
+const LABGATE_UI_VERSION = readPackageVersion();
+let uiPublishedVersionCache = null;
+let uiPublishedVersionInFlight = null;
+let uiSelfUpdateState = {
+    status: 'idle',
+    startedAt: null,
+    finishedAt: null,
+    message: '',
+    error: null,
+    latestVersion: null,
+};
+let uiSelfUpdatePromise = null;
 function getResultsStore() {
     if (!resultsStore) {
         resultsStore = new results_store_js_1.ResultsStore((0, config_js_1.getResultsDbPath)());
@@ -187,6 +206,256 @@ function commandErrorDetail(err) {
         .map((part) => String(part).trim())
         .join('\n');
 }
+function readPackageVersion() {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(PACKAGE_JSON_PATH, 'utf-8'));
+        const version = typeof parsed?.version === 'string' ? parsed.version.trim() : '';
+        return version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function stripVersionPrefix(raw) {
+    return String(raw || '').trim().replace(/^v/i, '');
+}
+function parseSemverTriplet(version) {
+    const normalized = stripVersionPrefix(version).split('-', 1)[0];
+    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareSemverStrings(a, b) {
+    const left = parseSemverTriplet(a);
+    const right = parseSemverTriplet(b);
+    if (!left || !right)
+        return null;
+    for (let i = 0; i < 3; i += 1) {
+        if (left[i] > right[i])
+            return 1;
+        if (left[i] < right[i])
+            return -1;
+    }
+    return 0;
+}
+function getUiBuildId() {
+    try {
+        const st = (0, fs_1.statSync)(HTML_PATH);
+        return `${LABGATE_UI_VERSION}:${st.size}:${Math.floor(st.mtimeMs)}`;
+    }
+    catch {
+        return `${LABGATE_UI_VERSION}:unknown`;
+    }
+}
+function normalizeNpmVersionValue(raw) {
+    if (typeof raw === 'string') {
+        const cleaned = stripVersionPrefix(raw).trim();
+        return cleaned || null;
+    }
+    if (Array.isArray(raw)) {
+        const versions = raw
+            .map((entry) => normalizeNpmVersionValue(entry))
+            .filter((entry) => !!entry);
+        if (versions.length === 0)
+            return null;
+        const sorted = [...versions].sort((a, b) => {
+            const cmp = compareSemverStrings(a, b);
+            if (cmp !== null)
+                return cmp;
+            return a.localeCompare(b);
+        });
+        return sorted[sorted.length - 1] || null;
+    }
+    return null;
+}
+function parseNpmVersionOutput(rawOutput) {
+    const text = String(rawOutput || '').trim();
+    if (!text)
+        return null;
+    try {
+        return normalizeNpmVersionValue(JSON.parse(text));
+    }
+    catch {
+        const cleaned = stripVersionPrefix(text.replace(/^"+|"+$/g, '').trim());
+        return cleaned || null;
+    }
+}
+function summarizeCommandError(err) {
+    const detail = commandErrorDetail(err);
+    const firstLine = detail
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return 'Could not reach npm registry.';
+    return firstLine.length > 180 ? `${firstLine.slice(0, 177)}...` : firstLine;
+}
+async function fetchPublishedUiVersion() {
+    const checkedAt = new Date().toISOString();
+    try {
+        const result = await execFileAsync('npm', ['view', UI_VERSION_NPM_PACKAGE, 'version', '--json'], {
+            timeout: UI_VERSION_CHECK_TIMEOUT_MS,
+            maxBuffer: UI_VERSION_CHECK_MAX_BUFFER,
+        });
+        const latestVersion = parseNpmVersionOutput(String(result?.stdout || ''));
+        if (!latestVersion) {
+            return {
+                latestVersion: null,
+                checkedAt,
+                error: 'npm returned an unreadable version.',
+            };
+        }
+        return {
+            latestVersion,
+            checkedAt,
+            error: null,
+        };
+    }
+    catch (err) {
+        return {
+            latestVersion: null,
+            checkedAt,
+            error: summarizeCommandError(err),
+        };
+    }
+}
+async function getPublishedUiVersionCached(force = false) {
+    const now = Date.now();
+    if (!force && uiPublishedVersionCache && (now - uiPublishedVersionCache.fetchedAtMs) < UI_VERSION_CACHE_TTL_MS) {
+        return uiPublishedVersionCache.value;
+    }
+    if (!force && !uiPublishedVersionCache) {
+        return {
+            latestVersion: null,
+            checkedAt: '',
+            error: null,
+        };
+    }
+    if (uiPublishedVersionInFlight)
+        return uiPublishedVersionInFlight;
+    uiPublishedVersionInFlight = fetchPublishedUiVersion()
+        .then((value) => {
+        uiPublishedVersionCache = { value, fetchedAtMs: Date.now() };
+        return value;
+    })
+        .finally(() => {
+        uiPublishedVersionInFlight = null;
+    });
+    return uiPublishedVersionInFlight;
+}
+function getActiveContainerSessionCount() {
+    const dir = (0, config_js_1.getSessionsDir)();
+    if (!(0, fs_1.existsSync)(dir))
+        return 0;
+    const localHost = (0, os_1.hostname)();
+    const files = (0, fs_1.readdirSync)(dir).filter((f) => f.endsWith('.json'));
+    let active = 0;
+    for (const file of files) {
+        try {
+            const path = (0, path_1.join)(dir, file);
+            const data = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+            if (data.node === localHost) {
+                try {
+                    process.kill(Number(data.pid), 0);
+                }
+                catch {
+                    try {
+                        (0, fs_1.unlinkSync)(path);
+                    }
+                    catch { /* best effort */ }
+                    continue;
+                }
+            }
+            active += 1;
+        }
+        catch {
+            // Skip unparseable files.
+        }
+    }
+    return active;
+}
+async function getActiveWebTerminalSessionCount() {
+    const localHost = (0, os_1.hostname)();
+    const records = (0, web_terminal_js_1.listWebTerminalRecords)();
+    let active = 0;
+    for (const record of records) {
+        if (record.status !== 'running')
+            continue;
+        if (record.node !== localHost) {
+            active += 1;
+            continue;
+        }
+        let alive = false;
+        try {
+            alive = await (0, web_terminal_js_1.hasTmuxSession)(record.tmuxSession);
+        }
+        catch {
+            alive = false;
+        }
+        if (alive) {
+            active += 1;
+        }
+        else {
+            (0, web_terminal_js_1.updateWebTerminalRecordStatus)(record.id, { status: 'exited', exitCode: record.exitCode ?? 0, error: null });
+        }
+    }
+    return active;
+}
+async function getActiveUiUsage() {
+    const containerSessions = getActiveContainerSessionCount();
+    const webTerminalSessions = await getActiveWebTerminalSessionCount();
+    return {
+        containerSessions,
+        webTerminalSessions,
+        total: containerSessions + webTerminalSessions,
+    };
+}
+function isUiUpdateInProgress() {
+    return !!uiSelfUpdatePromise || uiSelfUpdateState.status === 'running';
+}
+function runUiSelfUpdate() {
+    if (uiSelfUpdatePromise)
+        return;
+    const startedAt = new Date().toISOString();
+    uiSelfUpdateState = {
+        status: 'running',
+        startedAt,
+        finishedAt: null,
+        message: `Installing ${UI_VERSION_NPM_PACKAGE}@latest...`,
+        error: null,
+        latestVersion: null,
+    };
+    uiSelfUpdatePromise = (async () => {
+        try {
+            await execFileAsync('npm', ['install', '-g', `${UI_VERSION_NPM_PACKAGE}@latest`], {
+                timeout: UI_SELF_UPDATE_TIMEOUT_MS,
+                maxBuffer: UI_SELF_UPDATE_MAX_BUFFER,
+            });
+            const published = await getPublishedUiVersionCached(true);
+            uiSelfUpdateState = {
+                status: 'success',
+                startedAt,
+                finishedAt: new Date().toISOString(),
+                message: 'Update complete. Restart `labgate ui` to load the new version.',
+                error: null,
+                latestVersion: published.latestVersion,
+            };
+        }
+        catch (err) {
+            uiSelfUpdateState = {
+                status: 'error',
+                startedAt,
+                finishedAt: new Date().toISOString(),
+                message: 'Update failed.',
+                error: summarizeCommandError(err),
+                latestVersion: null,
+            };
+        }
+    })().finally(() => {
+        uiSelfUpdatePromise = null;
+    });
+}
 function isPodmanNotReadyError(error) {
     return /podman is installed but not ready/i.test(error || '');
 }
@@ -1086,7 +1355,7 @@ function isClaudeAuthenticationFailure(event, assistantSnapshot, stderrText) {
     const authRe = /oauth token has expired|authentication_error|failed to authenticate|api error:\s*401/i;
     return authRe.test(packed) || authRe.test(message);
 }
-function buildClaudeHeadlessApptainerArgs(config, workdir, prompt, resumeSessionId) {
+function buildClaudeHeadlessApptainerArgs(config, workdir, prompt, resumeSessionId, runWithAllowedPermissions) {
     const sandboxHome = (0, config_js_1.getSandboxHome)();
     const sifPath = (0, path_1.join)((0, config_js_1.getImagesDir)(), (0, container_js_1.imageToSifName)(config.image));
     const resume = resumeSessionId.trim();
@@ -1128,6 +1397,7 @@ function buildClaudeHeadlessApptainerArgs(config, workdir, prompt, resumeSession
         '--output-format',
         'stream-json',
         '--include-partial-messages',
+        ...(runWithAllowedPermissions ? ['--dangerously-skip-permissions'] : []),
         ...(resume ? ['--resume', resume] : []),
         prompt,
     ];
@@ -1380,7 +1650,7 @@ async function startClaudeHeadlessWsRun(ws, record, prompt, resumeSessionId) {
         });
         return () => { };
     }
-    const args = buildClaudeHeadlessApptainerArgs(config, record.workdir, trimmedPrompt, resumeSessionId);
+    const args = buildClaudeHeadlessApptainerArgs(config, record.workdir, trimmedPrompt, resumeSessionId, (0, config_js_1.shouldClaudeHeadlessRunWithAllowedPermissions)(config));
     const child = (0, child_process_1.spawn)('apptainer', args, {
         cwd: record.workdir,
         env: process.env,
@@ -1653,6 +1923,8 @@ async function handlePostConfig(req, res) {
         obj.audit = incoming.audit;
         if (incoming.slurm)
             obj.slurm = incoming.slurm;
+        if (incoming.headless)
+            obj.headless = incoming.headless;
         const { writeFileSync } = await import('fs');
         writeFileSync(configPath, JSON.stringify(obj, null, 2) + '\n', { encoding: 'utf-8', mode: config_js_1.PRIVATE_FILE_MODE });
         (0, config_js_1.ensurePrivateFile)(configPath);
@@ -1665,6 +1937,65 @@ async function handlePostConfig(req, res) {
 function handleGetConfigPath(_req, res) {
     json(res, { path: (0, config_js_1.getConfigPath)() });
 }
+async function handleGetUiVersion(reqUrl, res) {
+    const forceRefresh = reqUrl.searchParams.get('refresh') === '1';
+    const published = await getPublishedUiVersionCached(forceRefresh);
+    const runningVersion = LABGATE_UI_VERSION;
+    const latestVersion = published.latestVersion;
+    let updateAvailable = false;
+    if (latestVersion) {
+        const cmp = compareSemverStrings(latestVersion, runningVersion);
+        updateAvailable = cmp === null
+            ? stripVersionPrefix(latestVersion) !== stripVersionPrefix(runningVersion)
+            : cmp > 0;
+    }
+    json(res, {
+        ok: true,
+        runningVersion,
+        uiBuildId: getUiBuildId(),
+        latestVersion,
+        latestCheckedAt: published.checkedAt,
+        updateAvailable,
+        updateCommand: `npm install -g ${UI_VERSION_NPM_PACKAGE}@latest`,
+        restartCommand: 'labgate ui',
+        checkError: published.error,
+    });
+}
+function handleGetUiUpdateStatus(_req, res) {
+    json(res, {
+        ok: true,
+        status: uiSelfUpdateState.status,
+        startedAt: uiSelfUpdateState.startedAt,
+        finishedAt: uiSelfUpdateState.finishedAt,
+        message: uiSelfUpdateState.message,
+        error: uiSelfUpdateState.error,
+        latestVersion: uiSelfUpdateState.latestVersion,
+        inProgress: isUiUpdateInProgress(),
+    });
+}
+async function handlePostUiUpdate(_req, res) {
+    if (isUiUpdateInProgress()) {
+        json(res, { ok: false, code: 'in_progress', error: 'An update is already running.' }, 409);
+        return;
+    }
+    const usage = await getActiveUiUsage();
+    if (usage.total > 0) {
+        json(res, {
+            ok: false,
+            code: 'in_use',
+            error: 'Stop active sessions before updating LabGate.',
+            activeUsage: usage,
+        }, 409);
+        return;
+    }
+    runUiSelfUpdate();
+    json(res, {
+        ok: true,
+        started: true,
+        status: uiSelfUpdateState.status,
+        message: uiSelfUpdateState.message,
+    });
+}
 const INSTRUCTION_FILE_MAP = {
     'agent.md': 'AGENTS.md',
     'agents.md': 'AGENTS.md',
@@ -5571,6 +5902,20 @@ function upgradeBadRequest(socket) {
         // Best effort.
     }
 }
+function upgradeServiceUnavailable(socket) {
+    try {
+        socket.write('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
+    }
+    catch {
+        // Best effort.
+    }
+    try {
+        socket.destroy();
+    }
+    catch {
+        // Best effort.
+    }
+}
 /**
  * Start the settings UI server.
  * Returns the HTTP server so callers can close it when done.
@@ -5790,6 +6135,18 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             return;
         }
         try {
+            if (isUiUpdateInProgress() &&
+                pathname.startsWith('/api/') &&
+                method !== 'GET' &&
+                method !== 'HEAD' &&
+                pathname !== '/api/ui/update') {
+                json(res, {
+                    ok: false,
+                    code: 'update_in_progress',
+                    error: 'LabGate update in progress. Write actions are temporarily locked.',
+                }, 503);
+                return;
+            }
             if (pathname.startsWith('/api/') &&
                 method !== 'GET' &&
                 method !== 'HEAD' &&
@@ -5808,6 +6165,15 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             else if (pathname === '/api/config/path' && method === 'GET') {
                 handleGetConfigPath(req, res);
             }
+            else if (pathname === '/api/ui/version' && method === 'GET') {
+                await handleGetUiVersion(reqUrl, res);
+            }
+            else if (pathname === '/api/ui/update/status' && method === 'GET') {
+                handleGetUiUpdateStatus(req, res);
+            }
+            else if (pathname === '/api/ui/update' && method === 'POST') {
+                await handlePostUiUpdate(req, res);
+            }
             else if (pathname === '/api/sessions' && method === 'GET') {
                 await handleGetSessions(req, res);
             }
@@ -6029,6 +6395,10 @@ function startUI(optsOrPort = {}, standaloneArg = true) {
             upgradeBadRequest(socket);
             return;
         }
+        if (isUiUpdateInProgress()) {
+            upgradeServiceUnavailable(socket);
+            return;
+        }
         if (useTcp) {
             const auth = isAuthorizedRequest(req, reqUrl, uiAccessToken);
             if (!auth.ok) {