@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/lsp/client.js

@@ -0,0 +1,533 @@
+import { spawn } from 'child_process';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from 'vscode-jsonrpc/node.js';
+import { getLanguageId } from './language.js';
+import { logger } from '../logger.js';
+const DIAGNOSTICS_DEBOUNCE_MS = 150;
+const DIAGNOSTICS_DOCUMENT_WAIT_TIMEOUT_MS = 5000;
+const DIAGNOSTICS_FULL_WAIT_TIMEOUT_MS = 10000;
+const DIAGNOSTICS_REQUEST_TIMEOUT_MS = 3000;
+const INITIALIZE_TIMEOUT_MS = 45000;
+const SHUTDOWN_TIMEOUT_MS = 2000;
+const FILE_CHANGE_CREATED = 1;
+const FILE_CHANGE_CHANGED = 2;
+const FILE_CHANGE_DELETED = 3;
+const TEXT_DOCUMENT_SYNC_INCREMENTAL = 2;
+function withTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function getFilePath(uri) {
+    if (!uri.startsWith('file://'))
+        return undefined;
+    try {
+        return path.normalize(fileURLToPath(uri));
+    }
+    catch {
+        return undefined;
+    }
+}
+function getSyncKind(capabilities) {
+    const sync = capabilities?.textDocumentSync;
+    if (typeof sync === 'number')
+        return sync;
+    return sync?.change;
+}
+function endPosition(text) {
+    const lines = text.split(/\r\n|\r|\n/);
+    return { line: lines.length - 1, character: lines[lines.length - 1]?.length ?? 0 };
+}
+function dedupeDiagnostics(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const key = JSON.stringify({
+            code: item.code,
+            severity: item.severity,
+            message: item.message,
+            source: item.source,
+            range: item.range,
+        });
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function configurationValue(settings, section) {
+    if (!section)
+        return settings ?? null;
+    return (section.split('.').reduce((acc, key) => {
+        if (!acc || typeof acc !== 'object' || !(key in acc))
+            return undefined;
+        return acc[key];
+    }, settings) ?? null);
+}
+function shouldSeedDiagnosticsOnFirstPush(serverID) {
+    return serverID === 'typescript';
+}
+export class HostLspClient {
+    serverID;
+    root;
+    process;
+    connection;
+    initialization;
+    documents = new Map();
+    pushDiagnostics = new Map();
+    pullDiagnostics = new Map();
+    published = new Map();
+    diagnosticRegistrations = new Map();
+    registrationListeners = new Set();
+    diagnosticListeners = new Set();
+    capabilities;
+    closed = false;
+    constructor(input) {
+        this.serverID = input.serverID;
+        this.root = path.resolve(input.root);
+        this.process = input.process;
+        this.connection = input.connection;
+        this.initialization = input.initialization;
+    }
+    static async create(input) {
+        logger.info(`[lsp] starting ${input.serverID}: ${input.command.command} ${input.command.args.join(' ')}`);
+        const child = spawn(input.command.command, input.command.args, {
+            cwd: input.command.cwd,
+            env: input.command.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stderr.on('data', (data) => {
+            const text = data.toString().trim();
+            if (text)
+                logger.info(`[lsp:${input.serverID}:stderr] ${text.slice(0, 1000)}`);
+        });
+        const connection = createMessageConnection(new StreamMessageReader(child.stdout), new StreamMessageWriter(child.stdin));
+        const client = new HostLspClient({
+            serverID: input.serverID,
+            root: input.root,
+            process: child,
+            connection,
+            initialization: input.command.initialization,
+        });
+        client.registerHandlers();
+        connection.listen();
+        await client.initialize();
+        return client;
+    }
+    get diagnostics() {
+        const result = new Map();
+        for (const key of new Set([...this.pushDiagnostics.keys(), ...this.pullDiagnostics.keys()])) {
+            result.set(key, dedupeDiagnostics([...(this.pushDiagnostics.get(key) ?? []), ...(this.pullDiagnostics.get(key) ?? [])]));
+        }
+        return result;
+    }
+    async touchFile(filePath, diagnostics) {
+        const after = Date.now();
+        const version = await this.openOrChange(filePath);
+        if (diagnostics)
+            await this.waitForDiagnostics({ path: filePath, version, mode: diagnostics, after });
+        return version;
+    }
+    async closeFile(filePath) {
+        const normalizedPath = path.resolve(filePath);
+        const uri = pathToFileURL(normalizedPath).href;
+        const wasOpen = this.documents.delete(normalizedPath);
+        this.pushDiagnostics.delete(normalizedPath);
+        this.pullDiagnostics.delete(normalizedPath);
+        if (this.closed)
+            return;
+        await this.connection.sendNotification('workspace/didChangeWatchedFiles', {
+            changes: [{ uri, type: FILE_CHANGE_DELETED }],
+        });
+        if (wasOpen) {
+            await this.connection.sendNotification('textDocument/didClose', {
+                textDocument: { uri },
+            });
+        }
+    }
+    async hover(input) {
+        return this.connection.sendRequest('textDocument/hover', {
+            textDocument: { uri: pathToFileURL(input.filePath).href },
+            position: input.position,
+        });
+    }
+    async definition(input) {
+        return this.connection.sendRequest('textDocument/definition', {
+            textDocument: { uri: pathToFileURL(input.filePath).href },
+            position: input.position,
+        });
+    }
+    async references(input) {
+        return this.connection.sendRequest('textDocument/references', {
+            textDocument: { uri: pathToFileURL(input.filePath).href },
+            position: input.position,
+            context: { includeDeclaration: true },
+        });
+    }
+    async implementation(input) {
+        return this.connection.sendRequest('textDocument/implementation', {
+            textDocument: { uri: pathToFileURL(input.filePath).href },
+            position: input.position,
+        });
+    }
+    async prepareCallHierarchy(input) {
+        return this.connection.sendRequest('textDocument/prepareCallHierarchy', {
+            textDocument: { uri: pathToFileURL(input.filePath).href },
+            position: input.position,
+        });
+    }
+    async incomingCalls(item) {
+        return this.connection.sendRequest('callHierarchy/incomingCalls', { item });
+    }
+    async outgoingCalls(item) {
+        return this.connection.sendRequest('callHierarchy/outgoingCalls', { item });
+    }
+    async documentSymbol(filePath) {
+        return this.connection.sendRequest('textDocument/documentSymbol', {
+            textDocument: { uri: pathToFileURL(filePath).href },
+        });
+    }
+    async workspaceSymbol(query) {
+        return this.connection.sendRequest('workspace/symbol', { query });
+    }
+    async status() {
+        return {
+            id: this.serverID,
+            root: this.root,
+            status: this.closed ? 'closed' : 'connected',
+            openFiles: this.documents.size,
+        };
+    }
+    async shutdown() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        logger.info(`[lsp] shutting down ${this.serverID} at ${this.root}`);
+        try {
+            await withTimeout(this.connection.sendRequest('shutdown', null), SHUTDOWN_TIMEOUT_MS, 'LSP shutdown');
+        }
+        catch (error) {
+            logger.warn(`[lsp] shutdown request failed for ${this.serverID}: ${error}`);
+        }
+        try {
+            await this.connection.sendNotification('exit');
+        }
+        catch (error) {
+            logger.warn(`[lsp] exit notification failed for ${this.serverID}: ${error}`);
+        }
+        try {
+            this.connection.end();
+            this.connection.dispose();
+        }
+        catch (error) {
+            logger.warn(`[lsp] connection dispose failed for ${this.serverID}: ${error}`);
+        }
+        if (!this.process.killed)
+            this.process.kill();
+    }
+    registerHandlers() {
+        this.connection.onNotification('textDocument/publishDiagnostics', (params) => {
+            const payload = params;
+            if (!payload.uri || !Array.isArray(payload.diagnostics))
+                return;
+            const filePath = getFilePath(payload.uri);
+            if (!filePath)
+                return;
+            this.published.set(filePath, {
+                at: Date.now(),
+                version: typeof payload.version === 'number' ? payload.version : undefined,
+            });
+            if (shouldSeedDiagnosticsOnFirstPush(this.serverID) && !this.pushDiagnostics.has(filePath)) {
+                this.pushDiagnostics.set(filePath, payload.diagnostics);
+            }
+            else {
+                this.pushDiagnostics.set(filePath, payload.diagnostics);
+            }
+            for (const listener of [...this.diagnosticListeners])
+                listener(filePath);
+        });
+        this.connection.onRequest('window/workDoneProgress/create', async () => null);
+        this.connection.onRequest('workspace/configuration', async (params) => {
+            const items = params.items ?? [];
+            return items.map((item) => configurationValue(this.initialization, item.section));
+        });
+        this.connection.onRequest('client/registerCapability', async (params) => {
+            const registrations = params.registrations ?? [];
+            let changed = false;
+            for (const registration of registrations) {
+                if (registration.method !== 'textDocument/diagnostic')
+                    continue;
+                this.diagnosticRegistrations.set(registration.id, registration);
+                changed = true;
+            }
+            if (changed)
+                this.emitRegistrationChange();
+            return null;
+        });
+        this.connection.onRequest('client/unregisterCapability', async (params) => {
+            const registrations = params.unregisterations ?? [];
+            let changed = false;
+            for (const registration of registrations) {
+                if (registration.method !== 'textDocument/diagnostic')
+                    continue;
+                this.diagnosticRegistrations.delete(registration.id);
+                changed = true;
+            }
+            if (changed)
+                this.emitRegistrationChange();
+            return null;
+        });
+        this.connection.onRequest('workspace/workspaceFolders', async () => [
+            { name: path.basename(this.root) || 'workspace', uri: pathToFileURL(this.root).href },
+        ]);
+        this.connection.onRequest('workspace/diagnostic/refresh', async () => null);
+    }
+    async initialize() {
+        const initialized = await withTimeout(this.connection.sendRequest('initialize', {
+            rootUri: pathToFileURL(this.root).href,
+            processId: this.process.pid,
+            workspaceFolders: [{ name: path.basename(this.root) || 'workspace', uri: pathToFileURL(this.root).href }],
+            initializationOptions: { ...(this.initialization ?? {}) },
+            capabilities: {
+                window: { workDoneProgress: true },
+                workspace: {
+                    configuration: true,
+                    didChangeWatchedFiles: { dynamicRegistration: true },
+                    diagnostics: { refreshSupport: false },
+                    workspaceFolders: true,
+                },
+                textDocument: {
+                    synchronization: { didOpen: true, didChange: true, didClose: true },
+                    diagnostic: { dynamicRegistration: true, relatedDocumentSupport: true },
+                    publishDiagnostics: { versionSupport: false },
+                    hover: { contentFormat: ['markdown', 'plaintext'] },
+                    definition: { linkSupport: true },
+                    implementation: { linkSupport: true },
+                    references: {},
+                    callHierarchy: { dynamicRegistration: false },
+                    documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+                },
+            },
+        }), INITIALIZE_TIMEOUT_MS, `LSP initialize ${this.serverID}`);
+        this.capabilities = initialized.capabilities;
+        await this.connection.sendNotification('initialized', {});
+        if (this.initialization) {
+            await this.connection.sendNotification('workspace/didChangeConfiguration', { settings: this.initialization });
+        }
+        logger.info(`[lsp] initialized ${this.serverID} at ${this.root}`);
+    }
+    async openOrChange(filePath) {
+        const normalizedPath = path.resolve(filePath);
+        const uri = pathToFileURL(normalizedPath).href;
+        const text = await readFile(normalizedPath, 'utf8');
+        const existing = this.documents.get(normalizedPath);
+        if (existing) {
+            await this.connection.sendNotification('workspace/didChangeWatchedFiles', {
+                changes: [{ uri, type: FILE_CHANGE_CHANGED }],
+            });
+            const version = existing.version + 1;
+            this.documents.set(normalizedPath, { version, text });
+            await this.connection.sendNotification('textDocument/didChange', {
+                textDocument: { uri, version },
+                contentChanges: getSyncKind(this.capabilities) === TEXT_DOCUMENT_SYNC_INCREMENTAL
+                    ? [{ range: { start: { line: 0, character: 0 }, end: endPosition(existing.text) }, text }]
+                    : [{ text }],
+            });
+            return version;
+        }
+        this.pushDiagnostics.delete(normalizedPath);
+        this.pullDiagnostics.delete(normalizedPath);
+        await this.connection.sendNotification('workspace/didChangeWatchedFiles', {
+            changes: [{ uri, type: FILE_CHANGE_CREATED }],
+        });
+        await this.connection.sendNotification('textDocument/didOpen', {
+            textDocument: {
+                uri,
+                languageId: getLanguageId(normalizedPath),
+                version: 0,
+                text,
+            },
+        });
+        this.documents.set(normalizedPath, { version: 0, text });
+        return 0;
+    }
+    async waitForDiagnostics(request) {
+        const normalizedPath = path.resolve(request.path);
+        const startedAt = request.after ?? Date.now();
+        const timeout = request.mode === 'document' ? DIAGNOSTICS_DOCUMENT_WAIT_TIMEOUT_MS : DIAGNOSTICS_FULL_WAIT_TIMEOUT_MS;
+        const pull = request.mode === 'document' ? await this.requestDocumentDiagnostics(normalizedPath) : await this.requestFullDiagnostics(normalizedPath);
+        if (pull.matched || pull.handled)
+            return;
+        await Promise.race([
+            this.waitForFreshPush({ path: normalizedPath, version: request.version, after: startedAt, timeout }),
+            this.waitForRegistrationChange(timeout),
+        ]);
+        if (request.mode === 'document')
+            await this.requestDocumentDiagnostics(normalizedPath);
+        else
+            await this.requestFullDiagnostics(normalizedPath);
+    }
+    async requestDiagnosticReport(filePath, identifier) {
+        const report = await withTimeout(this.connection.sendRequest('textDocument/diagnostic', {
+            ...(identifier ? { identifier } : {}),
+            textDocument: { uri: pathToFileURL(filePath).href },
+        }), DIAGNOSTICS_REQUEST_TIMEOUT_MS, 'textDocument/diagnostic').catch(() => null);
+        if (!report)
+            return { handled: false, matched: false, byFile: new Map() };
+        const byFile = new Map();
+        let handled = false;
+        let matched = false;
+        const push = (target, items) => {
+            byFile.set(target, [...(byFile.get(target) ?? []), ...items]);
+        };
+        if (Array.isArray(report.items)) {
+            push(filePath, report.items);
+            handled = true;
+            matched = true;
+        }
+        const relatedDocuments = (report.relatedDocuments ?? {});
+        for (const [uri, related] of Object.entries(relatedDocuments)) {
+            const relatedPath = getFilePath(uri);
+            if (!relatedPath || !Array.isArray(related.items))
+                continue;
+            push(relatedPath, related.items);
+            handled = true;
+            matched = matched || relatedPath === filePath;
+        }
+        return { handled, matched, byFile };
+    }
+    async requestWorkspaceDiagnosticReport(identifier) {
+        const report = await withTimeout(this.connection.sendRequest('workspace/diagnostic', {
+            ...(identifier ? { identifier } : {}),
+            previousResultIds: [],
+        }), DIAGNOSTICS_REQUEST_TIMEOUT_MS, 'workspace/diagnostic').catch(() => null);
+        if (!report)
+            return { handled: false, matched: false, byFile: new Map() };
+        const byFile = new Map();
+        for (const item of report.items ?? []) {
+            const filePath = item.uri ? getFilePath(item.uri) : undefined;
+            if (!filePath || !Array.isArray(item.items))
+                continue;
+            byFile.set(filePath, [...(byFile.get(filePath) ?? []), ...item.items]);
+        }
+        return { handled: true, matched: false, byFile };
+    }
+    async requestDocumentDiagnostics(filePath) {
+        const identifiers = this.documentDiagnosticIdentifiers();
+        const supported = Boolean(this.capabilities?.diagnosticProvider) || identifiers.length > 0;
+        if (!supported)
+            return { handled: false, matched: false };
+        return this.mergeDiagnosticResults(filePath, await Promise.all([this.requestDiagnosticReport(filePath), ...identifiers.map((id) => this.requestDiagnosticReport(filePath, id))]));
+    }
+    async requestFullDiagnostics(filePath) {
+        const documentIdentifiers = this.documentDiagnosticIdentifiers();
+        const workspaceIdentifiers = this.workspaceDiagnosticIdentifiers();
+        const documentSupported = Boolean(this.capabilities?.diagnosticProvider) || documentIdentifiers.length > 0;
+        const workspaceSupported = workspaceIdentifiers.length > 0;
+        if (!documentSupported && !workspaceSupported)
+            return { handled: false, matched: false };
+        return this.mergeDiagnosticResults(filePath, await Promise.all([
+            ...(documentSupported ? [this.requestDiagnosticReport(filePath)] : []),
+            ...documentIdentifiers.map((id) => this.requestDiagnosticReport(filePath, id)),
+            ...(workspaceSupported ? [this.requestWorkspaceDiagnosticReport()] : []),
+            ...workspaceIdentifiers.map((id) => this.requestWorkspaceDiagnosticReport(id)),
+        ]));
+    }
+    mergeDiagnosticResults(filePath, results) {
+        const handled = results.some((result) => result.handled);
+        const matched = results.some((result) => result.matched || result.byFile.has(filePath));
+        if (!handled)
+            return { handled: false, matched: false };
+        const merged = new Map();
+        for (const result of results) {
+            for (const [target, items] of result.byFile.entries()) {
+                merged.set(target, [...(merged.get(target) ?? []), ...items]);
+            }
+        }
+        if (matched && !merged.has(filePath))
+            merged.set(filePath, []);
+        for (const [target, items] of merged.entries()) {
+            this.pullDiagnostics.set(target, dedupeDiagnostics(items));
+        }
+        return { handled, matched };
+    }
+    documentDiagnosticIdentifiers() {
+        return [
+            ...new Set([...this.diagnosticRegistrations.values()]
+                .filter((registration) => registration.registerOptions?.workspaceDiagnostics !== true)
+                .flatMap((registration) => registration.registerOptions?.identifier ?? [])),
+        ];
+    }
+    workspaceDiagnosticIdentifiers() {
+        return [
+            ...new Set([...this.diagnosticRegistrations.values()]
+                .filter((registration) => registration.registerOptions?.workspaceDiagnostics === true)
+                .flatMap((registration) => registration.registerOptions?.identifier ?? [])),
+        ];
+    }
+    waitForFreshPush(request) {
+        return new Promise((resolve) => {
+            let finished = false;
+            let debounceTimer;
+            const timers = {};
+            const finish = (value) => {
+                if (finished)
+                    return;
+                finished = true;
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                if (timers.timeout)
+                    clearTimeout(timers.timeout);
+                this.diagnosticListeners.delete(listener);
+                resolve(value);
+            };
+            const schedule = () => {
+                const hit = this.published.get(request.path);
+                if (!hit)
+                    return;
+                if (typeof hit.version === 'number' && hit.version !== request.version)
+                    return;
+                if (hit.at < request.after && hit.version !== request.version)
+                    return;
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => finish(true), Math.max(0, DIAGNOSTICS_DEBOUNCE_MS - (Date.now() - hit.at)));
+            };
+            const listener = (filePath) => {
+                if (filePath === request.path)
+                    schedule();
+            };
+            this.diagnosticListeners.add(listener);
+            timers.timeout = setTimeout(() => finish(false), request.timeout);
+            schedule();
+        });
+    }
+    waitForRegistrationChange(timeout) {
+        return new Promise((resolve) => {
+            let finished = false;
+            const finish = (value) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                this.registrationListeners.delete(listener);
+                resolve(value);
+            };
+            const listener = () => finish(true);
+            const timer = setTimeout(() => finish(false), timeout);
+            this.registrationListeners.add(listener);
+        });
+    }
+    emitRegistrationChange() {
+        for (const listener of [...this.registrationListeners])
+            listener();
+    }
+}

package/dist/sandbox/core/lsp/config.d.ts

@@ -0,0 +1,13 @@
+export type HostLspServerConfig = {
+    disabled?: boolean;
+    command?: string[];
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+    extensions?: string[];
+    rootMarkers?: string[];
+};
+export type HostLspConfig = {
+    enabled: boolean;
+    servers: Record<string, HostLspServerConfig>;
+};
+export declare function loadHostLspConfig(worktree: string): HostLspConfig;

package/dist/sandbox/core/lsp/config.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+export function loadHostLspConfig(worktree) {
+    const configPath = path.join(worktree, '.opencode', 'sandbox.json');
+    if (!existsSync(configPath))
+        return { enabled: true, servers: {} };
+    try {
+        const raw = JSON.parse(readFileSync(configPath, 'utf8'));
+        if (raw.lsp === false)
+            return { enabled: false, servers: {} };
+        if (raw.lsp === true || raw.lsp == null)
+            return { enabled: true, servers: {} };
+        if (typeof raw.lsp !== 'object')
+            return { enabled: true, servers: {} };
+        const servers = {};
+        for (const [serverID, value] of Object.entries(raw.lsp)) {
+            if (!value || typeof value !== 'object')
+                continue;
+            const item = value;
+            servers[serverID] = {
+                disabled: Boolean(item.disabled),
+                command: Array.isArray(item.command) ? item.command.map(String) : undefined,
+                env: item.env && typeof item.env === 'object' ? Object.fromEntries(Object.entries(item.env).map(([k, v]) => [k, String(v)])) : undefined,
+                initialization: item.initialization && typeof item.initialization === 'object'
+                    ? item.initialization
+                    : undefined,
+                extensions: Array.isArray(item.extensions) ? item.extensions.map(String) : undefined,
+                rootMarkers: Array.isArray(item.rootMarkers) ? item.rootMarkers.map(String) : undefined,
+            };
+        }
+        return { enabled: true, servers };
+    }
+    catch {
+        return { enabled: true, servers: {} };
+    }
+}

package/dist/sandbox/core/lsp/diagnostics.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from 'vscode-languageserver-types';
+export type DiagnosticCounts = {
+    errors: number;
+    warnings: number;
+    information: number;
+    hints: number;
+};
+export declare function countDiagnostics(diagnostics: Diagnostic[]): DiagnosticCounts;
+export declare function hasActionableDiagnostics(diagnostics: Diagnostic[]): boolean;
+export declare function severityLabel(severity?: Diagnostic['severity']): "INFO" | "ERROR" | "WARN" | "HINT";
+export declare function formatLspDiagnosticOutput(filePath: string, diagnostics: Diagnostic[]): string;
+export declare function formatLspUnavailable(error: unknown): string;

package/dist/sandbox/core/lsp/diagnostics.js

@@ -0,0 +1,65 @@
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { HostLspUnavailableError } from './manager.js';
+export function countDiagnostics(diagnostics) {
+    return diagnostics.reduce((counts, diagnostic) => {
+        switch (diagnostic.severity) {
+            case DiagnosticSeverity.Error:
+                counts.errors++;
+                break;
+            case DiagnosticSeverity.Warning:
+                counts.warnings++;
+                break;
+            case DiagnosticSeverity.Information:
+                counts.information++;
+                break;
+            case DiagnosticSeverity.Hint:
+                counts.hints++;
+                break;
+            default:
+                counts.warnings++;
+        }
+        return counts;
+    }, { errors: 0, warnings: 0, information: 0, hints: 0 });
+}
+export function hasActionableDiagnostics(diagnostics) {
+    const counts = countDiagnostics(diagnostics);
+    return counts.errors > 0 || counts.warnings > 0;
+}
+export function severityLabel(severity) {
+    switch (severity) {
+        case DiagnosticSeverity.Error:
+            return 'ERROR';
+        case DiagnosticSeverity.Warning:
+            return 'WARN';
+        case DiagnosticSeverity.Information:
+            return 'INFO';
+        case DiagnosticSeverity.Hint:
+            return 'HINT';
+        default:
+            return 'WARN';
+    }
+}
+export function formatLspDiagnosticOutput(filePath, diagnostics) {
+    if (diagnostics.length === 0)
+        return '';
+    const counts = countDiagnostics(diagnostics);
+    const title = counts.errors > 0
+        ? `LSP errors detected in ${filePath}, please fix:`
+        : counts.warnings > 0
+            ? `LSP warnings in ${filePath}:`
+            : `LSP diagnostics in ${filePath}:`;
+    const lines = diagnostics.map((diagnostic) => {
+        const line = diagnostic.range.start.line + 1;
+        const character = diagnostic.range.start.character + 1;
+        const source = diagnostic.source ? ` [${diagnostic.source}]` : '';
+        const code = diagnostic.code != null ? ` (${String(diagnostic.code)})` : '';
+        return `  ${severityLabel(diagnostic.severity)} ${filePath}:${line}:${character}${source}${code}: ${diagnostic.message}`;
+    });
+    return `${title}\n${lines.join('\n')}`;
+}
+export function formatLspUnavailable(error) {
+    if (error instanceof HostLspUnavailableError)
+        return `Host LSP unavailable: ${error.message}`;
+    const message = error instanceof Error ? error.message : String(error);
+    return `Host LSP failed: ${message}`;
+}

package/dist/sandbox/core/lsp/index.d.ts

@@ -0,0 +1,4 @@
+export { hostLspManager, HostLspManager, HostLspUnavailableError } from './manager.js';
+export { formatLspDiagnosticOutput, formatLspUnavailable, hasActionableDiagnostics } from './diagnostics.js';
+export { notifyHostLspAfterWrite, notifyHostLspAfterDelete, warmHostLspFile, waitForHostFile } from './tooling.js';
+export { getLanguageId, LANGUAGE_EXTENSIONS } from './language.js';

package/dist/sandbox/core/lsp/index.js

@@ -0,0 +1,4 @@
+export { hostLspManager, HostLspManager, HostLspUnavailableError } from './manager.js';
+export { formatLspDiagnosticOutput, formatLspUnavailable, hasActionableDiagnostics } from './diagnostics.js';
+export { notifyHostLspAfterWrite, notifyHostLspAfterDelete, warmHostLspFile, waitForHostFile } from './tooling.js';
+export { getLanguageId, LANGUAGE_EXTENSIONS } from './language.js';