@wavexzore/sandbox 0.1.0

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

@@ -0,0 +1,24 @@
+import type { HostLspConfig, HostLspServerConfig } from './config.js';
+export declare const LANGUAGE_EXTENSIONS: Record<string, string>;
+export type HostLspCommand = {
+    command: string;
+    args: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    initialization?: Record<string, unknown>;
+};
+export type HostLspServer = {
+    id: string;
+    extensions: string[];
+    rootMarkers: string[];
+    resolveCommand(root: string, worktree: string, config?: HostLspServerConfig): HostLspCommand | undefined;
+};
+export type ResolvedHostLspServer = {
+    id: string;
+    root: string;
+    command: HostLspCommand;
+};
+export declare function getLanguageId(filePath: string): string;
+export declare function supportsHostLsp(filePath: string, config: HostLspConfig): boolean;
+export declare function serverInstallHint(filePath: string): string;
+export declare function resolveHostLspServers(filePath: string, worktree: string, config: HostLspConfig): Promise<ResolvedHostLspServer[]>;

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

@@ -0,0 +1,249 @@
+import { accessSync, constants, existsSync } from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+export const LANGUAGE_EXTENSIONS = {
+    '.cjs': 'javascript',
+    '.cts': 'typescript',
+    '.go': 'go',
+    '.js': 'javascript',
+    '.jsx': 'javascriptreact',
+    '.mjs': 'javascript',
+    '.mts': 'typescript',
+    '.py': 'python',
+    '.pyi': 'python',
+    '.ts': 'typescript',
+    '.tsx': 'typescriptreact',
+};
+const TYPESCRIPT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
+const GO_EXTENSIONS = ['.go'];
+const PYTHON_EXTENSIONS = ['.py', '.pyi'];
+const DEFAULT_SERVERS = [
+    {
+        id: 'typescript',
+        extensions: TYPESCRIPT_EXTENSIONS,
+        rootMarkers: ['tsconfig.json', 'jsconfig.json', 'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb'],
+        resolveCommand(root, worktree, config) {
+            const configured = commandFromConfig(root, worktree, config);
+            if (configured)
+                return configured;
+            const bin = findLocalBin('typescript-language-server', root, worktree) || findOnPath('typescript-language-server');
+            if (!bin)
+                return undefined;
+            const tsserver = resolveModuleFrom('typescript/lib/tsserver.js', [root, worktree]);
+            return {
+                command: bin,
+                args: ['--stdio'],
+                cwd: root,
+                env: process.env,
+                initialization: tsserver ? { tsserver: { path: tsserver } } : undefined,
+            };
+        },
+    },
+    {
+        id: 'go',
+        extensions: GO_EXTENSIONS,
+        rootMarkers: ['go.work', 'go.mod'],
+        resolveCommand(root, worktree, config) {
+            const configured = commandFromConfig(root, worktree, config);
+            if (configured)
+                return configured;
+            const bin = findOnPath('gopls');
+            if (!bin)
+                return undefined;
+            return { command: bin, args: [], cwd: root, env: process.env };
+        },
+    },
+    {
+        id: 'python',
+        extensions: PYTHON_EXTENSIONS,
+        rootMarkers: ['pyproject.toml', 'setup.py', 'setup.cfg', 'requirements.txt', 'Pipfile', 'poetry.lock'],
+        resolveCommand(root, worktree, config) {
+            const configured = commandFromConfig(root, worktree, config);
+            if (configured)
+                return configured;
+            const venvServer = findVenvBinary('pylsp', root, worktree);
+            if (venvServer)
+                return { command: venvServer, args: [], cwd: root, env: process.env };
+            const pylsp = findOnPath('pylsp');
+            if (pylsp)
+                return { command: pylsp, args: [], cwd: root, env: process.env };
+            const python = findOnPath('python3') || findOnPath('python');
+            if (python && hasPythonModule(python, 'pylsp')) {
+                return { command: python, args: ['-m', 'pylsp'], cwd: root, env: process.env };
+            }
+            return undefined;
+        },
+    },
+];
+export function getLanguageId(filePath) {
+    return LANGUAGE_EXTENSIONS[path.extname(filePath).toLowerCase()] ?? 'plaintext';
+}
+export function supportsHostLsp(filePath, config) {
+    if (!config.enabled)
+        return false;
+    const ext = path.extname(filePath).toLowerCase();
+    return getServerDefinitions(config).some((server) => server.extensions.includes(ext));
+}
+export function serverInstallHint(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (TYPESCRIPT_EXTENSIONS.includes(ext)) {
+        return 'Install typescript and typescript-language-server in the host worktree, or configure .opencode/sandbox.json lsp.typescript.command.';
+    }
+    if (GO_EXTENSIONS.includes(ext)) {
+        return 'Install gopls on the host PATH, or configure .opencode/sandbox.json lsp.go.command.';
+    }
+    if (PYTHON_EXTENSIONS.includes(ext)) {
+        return 'Install python-lsp-server (pylsp) in the host venv/PATH, or configure .opencode/sandbox.json lsp.python.command.';
+    }
+    return `No host LSP server is configured for ${ext || 'this file type'}.`;
+}
+export async function resolveHostLspServers(filePath, worktree, config) {
+    if (!config.enabled)
+        return [];
+    const ext = path.extname(filePath).toLowerCase();
+    const definitions = getServerDefinitions(config).filter((server) => server.extensions.includes(ext));
+    const results = [];
+    for (const server of definitions) {
+        const root = findNearestRoot(path.dirname(filePath), worktree, server.rootMarkers) ?? path.resolve(worktree);
+        const command = server.resolveCommand(root, worktree, config.servers[server.id]);
+        if (!command)
+            continue;
+        results.push({ id: server.id, root, command });
+    }
+    return results;
+}
+function getServerDefinitions(config) {
+    return DEFAULT_SERVERS.flatMap((server) => {
+        const override = config.servers[server.id];
+        if (override?.disabled)
+            return [];
+        return [
+            {
+                ...server,
+                extensions: override?.extensions ?? server.extensions,
+                rootMarkers: override?.rootMarkers ?? server.rootMarkers,
+            },
+        ];
+    });
+}
+function findNearestRoot(startDir, stopDir, markers) {
+    let current = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (true) {
+        if (markers.some((marker) => existsSync(path.join(current, marker))))
+            return current;
+        if (current === stop || !isInsideOrEqual(current, stop))
+            return undefined;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function isInsideOrEqual(target, root) {
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function commandFromConfig(root, worktree, config) {
+    if (!config?.command?.length)
+        return undefined;
+    const [rawCommand, ...args] = config.command;
+    return {
+        command: resolveConfiguredCommand(rawCommand, root, worktree),
+        args,
+        cwd: root,
+        env: { ...process.env, ...(config.env ?? {}) },
+        initialization: config.initialization,
+    };
+}
+function resolveConfiguredCommand(command, root, worktree) {
+    if (path.isAbsolute(command))
+        return command;
+    if (command.startsWith('.') || command.includes('/')) {
+        const rootCandidate = path.resolve(root, command);
+        if (existsSync(rootCandidate))
+            return rootCandidate;
+        return path.resolve(worktree, command);
+    }
+    return command;
+}
+function executableCandidates(name) {
+    if (process.platform === 'win32' && !path.extname(name))
+        return [name + '.cmd', name + '.exe', name];
+    return [name];
+}
+function canExecute(filePath) {
+    try {
+        accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return existsSync(filePath);
+    }
+}
+function findOnPath(name) {
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const candidateName of executableCandidates(name)) {
+            const candidate = path.join(dir, candidateName);
+            if (canExecute(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+function findLocalBin(name, root, worktree) {
+    let current = path.resolve(root);
+    const stop = path.resolve(worktree);
+    while (true) {
+        for (const candidateName of executableCandidates(name)) {
+            const candidate = path.join(current, 'node_modules', '.bin', candidateName);
+            if (canExecute(candidate))
+                return candidate;
+        }
+        if (current === stop || !isInsideOrEqual(current, stop))
+            return undefined;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function findVenvBinary(name, root, worktree) {
+    let current = path.resolve(root);
+    const stop = path.resolve(worktree);
+    const binDir = process.platform === 'win32' ? 'Scripts' : 'bin';
+    while (true) {
+        for (const venvName of ['.venv', 'venv']) {
+            for (const candidateName of executableCandidates(name)) {
+                const candidate = path.join(current, venvName, binDir, candidateName);
+                if (canExecute(candidate))
+                    return candidate;
+            }
+        }
+        if (current === stop || !isInsideOrEqual(current, stop))
+            return undefined;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function resolveModuleFrom(moduleName, roots) {
+    for (const root of roots) {
+        try {
+            return require.resolve(moduleName, { paths: [root] });
+        }
+        catch (error) {
+            void error;
+        }
+    }
+    return undefined;
+}
+function hasPythonModule(python, moduleName) {
+    const result = spawnSync(python, ['-c', `import ${moduleName}`], { stdio: 'ignore', timeout: 3000 });
+    return result.status === 0;
+}

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

@@ -0,0 +1,77 @@
+import type { Diagnostic, Position } from 'vscode-languageserver-types';
+export declare class HostLspUnavailableError extends Error {
+    readonly filePath: string;
+    readonly reason: string;
+    constructor(filePath: string, reason: string);
+}
+type DiagnosticMode = 'document' | 'full';
+type LocationInput = {
+    sessionID: string;
+    worktree: string;
+    filePath: string;
+    position: Position;
+};
+export declare class HostLspManager {
+    private readonly clients;
+    private readonly spawning;
+    private readonly broken;
+    touchFile(input: {
+        sessionID: string;
+        worktree: string;
+        filePath: string;
+        diagnostics?: DiagnosticMode;
+    }): Promise<number>;
+    closeFile(input: {
+        sessionID: string;
+        worktree: string;
+        filePath: string;
+    }): Promise<void>;
+    diagnosticsForFile(input: {
+        sessionID: string;
+        worktree: string;
+        filePath: string;
+    }): Diagnostic[];
+    allDiagnostics(input?: {
+        sessionID?: string;
+        worktree?: string;
+    }): Map<string, Diagnostic[]>;
+    hover(input: LocationInput): Promise<unknown>;
+    definition(input: LocationInput): Promise<any[]>;
+    references(input: LocationInput): Promise<any[]>;
+    implementation(input: LocationInput): Promise<any[]>;
+    prepareCallHierarchy(input: LocationInput): Promise<unknown[]>;
+    incomingCalls(input: LocationInput): Promise<unknown[]>;
+    outgoingCalls(input: LocationInput): Promise<unknown[]>;
+    documentSymbol(input: {
+        sessionID: string;
+        worktree: string;
+        filePath: string;
+    }): Promise<unknown[]>;
+    workspaceSymbol(input: {
+        sessionID: string;
+        worktree: string;
+        query: string;
+    }): Promise<unknown[]>;
+    status(input?: {
+        sessionID?: string;
+    }): Promise<{
+        connected: any[];
+        broken: {
+            key: string;
+            reason: string;
+        }[];
+    }>;
+    hasClients(input: {
+        sessionID: string;
+        worktree: string;
+        filePath: string;
+    }): Promise<boolean>;
+    shutdownSession(sessionID: string): Promise<void>;
+    shutdownAll(): Promise<void>;
+    private runForFile;
+    private getClients;
+    private getExistingClientsForFile;
+    private spawnClient;
+}
+export declare const hostLspManager: HostLspManager;
+export {};

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

@@ -0,0 +1,237 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { HostLspClient } from './client.js';
+import { loadHostLspConfig } from './config.js';
+import { resolveHostLspServers, serverInstallHint, supportsHostLsp } from './language.js';
+import { logger } from '../logger.js';
+export class HostLspUnavailableError extends Error {
+    filePath;
+    reason;
+    constructor(filePath, reason) {
+        super(reason);
+        this.filePath = filePath;
+        this.reason = reason;
+        this.name = 'HostLspUnavailableError';
+    }
+}
+function keyFor(sessionID, serverID, root) {
+    return `${sessionID}\0${serverID}\0${root}`;
+}
+function normalizeHostFile(filePath) {
+    return path.resolve(filePath);
+}
+function isInsideOrEqual(target, root) {
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function flattenResults(items) {
+    return items.flatMap((item) => (Array.isArray(item) ? item : item ? [item] : []));
+}
+export class HostLspManager {
+    clients = new Map();
+    spawning = new Map();
+    broken = new Map();
+    async touchFile(input) {
+        const filePath = normalizeHostFile(input.filePath);
+        const clients = await this.getClients(input.sessionID, input.worktree, filePath);
+        await Promise.all(clients.map((record) => record.client.touchFile(filePath, input.diagnostics)));
+        return clients.length;
+    }
+    async closeFile(input) {
+        const filePath = normalizeHostFile(input.filePath);
+        const clients = await this.getExistingClientsForFile(input.sessionID, input.worktree, filePath);
+        await Promise.all(clients.map((record) => record.client.closeFile(filePath)));
+    }
+    diagnosticsForFile(input) {
+        const filePath = normalizeHostFile(input.filePath);
+        const diagnostics = [];
+        for (const record of this.clients.values()) {
+            if (record.sessionID !== input.sessionID)
+                continue;
+            if (!isInsideOrEqual(filePath, record.root))
+                continue;
+            diagnostics.push(...(record.client.diagnostics.get(filePath) ?? []));
+        }
+        return diagnostics;
+    }
+    allDiagnostics(input) {
+        const result = new Map();
+        for (const record of this.clients.values()) {
+            if (input?.sessionID && record.sessionID !== input.sessionID)
+                continue;
+            if (input?.worktree && path.resolve(record.worktree) !== path.resolve(input.worktree))
+                continue;
+            for (const [filePath, diagnostics] of record.client.diagnostics.entries()) {
+                result.set(filePath, [...(result.get(filePath) ?? []), ...diagnostics]);
+            }
+        }
+        return result;
+    }
+    async hover(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.hover({ filePath: input.filePath, position: input.position }));
+        return results.find(Boolean) ?? null;
+    }
+    async definition(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.definition({ filePath: input.filePath, position: input.position }).catch(() => null));
+        return flattenResults(results);
+    }
+    async references(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.references({ filePath: input.filePath, position: input.position }).catch(() => []));
+        return flattenResults(results);
+    }
+    async implementation(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.implementation({ filePath: input.filePath, position: input.position }).catch(() => null));
+        return flattenResults(results);
+    }
+    async prepareCallHierarchy(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.prepareCallHierarchy({ filePath: input.filePath, position: input.position }).catch(() => []));
+        return flattenResults(results);
+    }
+    async incomingCalls(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, async (client) => {
+            const items = (await client.prepareCallHierarchy({ filePath: input.filePath, position: input.position }).catch(() => [])) ?? [];
+            const calls = await Promise.all(items.map((item) => client.incomingCalls(item).catch(() => [])));
+            return flattenResults(calls);
+        });
+        return flattenResults(results);
+    }
+    async outgoingCalls(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, async (client) => {
+            const items = (await client.prepareCallHierarchy({ filePath: input.filePath, position: input.position }).catch(() => [])) ?? [];
+            const calls = await Promise.all(items.map((item) => client.outgoingCalls(item).catch(() => [])));
+            return flattenResults(calls);
+        });
+        return flattenResults(results);
+    }
+    async documentSymbol(input) {
+        await this.touchFile({ ...input, diagnostics: 'document' });
+        const results = await this.runForFile(input, (client) => client.documentSymbol(input.filePath).catch(() => []));
+        return flattenResults(results);
+    }
+    async workspaceSymbol(input) {
+        const records = [...this.clients.values()].filter((record) => record.sessionID === input.sessionID && path.resolve(record.worktree) === path.resolve(input.worktree));
+        const results = await Promise.all(records.map((record) => record.client.workspaceSymbol(input.query).catch(() => [])));
+        return flattenResults(results);
+    }
+    async status(input) {
+        const connected = [];
+        for (const record of this.clients.values()) {
+            if (input?.sessionID && record.sessionID !== input.sessionID)
+                continue;
+            connected.push({ ...(await record.client.status()), worktree: record.worktree });
+        }
+        return {
+            connected,
+            broken: [...this.broken.entries()].map(([key, reason]) => ({ key, reason })),
+        };
+    }
+    async hasClients(input) {
+        try {
+            return (await this.getClients(input.sessionID, input.worktree, normalizeHostFile(input.filePath))).length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async shutdownSession(sessionID) {
+        const records = [...this.clients.entries()].filter(([, record]) => record.sessionID === sessionID);
+        for (const [key, record] of records) {
+            this.clients.delete(key);
+            await record.client.shutdown().catch((error) => logger.warn(`[lsp] failed to shutdown ${record.serverID}: ${error}`));
+        }
+        for (const key of [...this.broken.keys()]) {
+            if (key.startsWith(`${sessionID}\0`))
+                this.broken.delete(key);
+        }
+    }
+    async shutdownAll() {
+        await Promise.all([...this.clients.values()].map((record) => record.client.shutdown().catch(() => undefined)));
+        this.clients.clear();
+        this.spawning.clear();
+        this.broken.clear();
+    }
+    async runForFile(input, fn) {
+        const filePath = normalizeHostFile(input.filePath);
+        const clients = await this.getClients(input.sessionID, input.worktree, filePath);
+        if (clients.length === 0) {
+            throw new HostLspUnavailableError(filePath, `No host LSP server available for ${path.extname(filePath) || 'this file'}. ${serverInstallHint(filePath)}`);
+        }
+        return Promise.all(clients.map((record) => fn(record.client)));
+    }
+    async getClients(sessionID, worktree, filePath) {
+        const hostWorktree = path.resolve(worktree);
+        if (!isInsideOrEqual(filePath, hostWorktree))
+            return [];
+        if (!existsSync(filePath)) {
+            throw new HostLspUnavailableError(filePath, `Host file not found for LSP validation: ${filePath}`);
+        }
+        const config = loadHostLspConfig(hostWorktree);
+        if (!supportsHostLsp(filePath, config))
+            return [];
+        const servers = await resolveHostLspServers(filePath, hostWorktree, config);
+        if (servers.length === 0) {
+            throw new HostLspUnavailableError(filePath, `No host LSP server available for ${path.extname(filePath) || 'this file'}. ${serverInstallHint(filePath)}`);
+        }
+        const records = [];
+        const attemptedKeys = [];
+        for (const server of servers) {
+            const key = keyFor(sessionID, server.id, server.root);
+            attemptedKeys.push(key);
+            const brokenReason = this.broken.get(key);
+            if (brokenReason)
+                throw new HostLspUnavailableError(filePath, brokenReason);
+            const existing = this.clients.get(key);
+            if (existing) {
+                records.push(existing);
+                continue;
+            }
+            const inflight = this.spawning.get(key);
+            if (inflight) {
+                const record = await inflight;
+                if (record)
+                    records.push(record);
+                continue;
+            }
+            const task = this.spawnClient(sessionID, hostWorktree, server.id, server.root, server.command, key);
+            this.spawning.set(key, task);
+            task.finally(() => {
+                if (this.spawning.get(key) === task)
+                    this.spawning.delete(key);
+            });
+            const record = await task;
+            if (record)
+                records.push(record);
+        }
+        if (records.length === 0) {
+            const reason = attemptedKeys.map((key) => this.broken.get(key)).find(Boolean);
+            throw new HostLspUnavailableError(filePath, reason ?? `No host LSP server available for ${path.extname(filePath) || 'this file'}. ${serverInstallHint(filePath)}`);
+        }
+        return records;
+    }
+    async getExistingClientsForFile(sessionID, worktree, filePath) {
+        const hostWorktree = path.resolve(worktree);
+        return [...this.clients.values()].filter((record) => record.sessionID === sessionID && path.resolve(record.worktree) === hostWorktree && isInsideOrEqual(filePath, record.root));
+    }
+    async spawnClient(sessionID, worktree, serverID, root, command, key) {
+        try {
+            const client = await HostLspClient.create({ serverID, root, command });
+            const record = { sessionID, worktree, serverID, root, client };
+            this.clients.set(key, record);
+            return record;
+        }
+        catch (error) {
+            const reason = `Failed to start host LSP server ${serverID} at ${root}: ${error?.message || error}`;
+            logger.error(`[lsp] ${reason}`);
+            this.broken.set(key, reason);
+            return undefined;
+        }
+    }
+}
+export const hostLspManager = new HostLspManager();

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

@@ -0,0 +1,14 @@
+import type { PathMapper } from '../path-map.js';
+type NotifyInput = {
+    sessionID: string;
+    worktree: string;
+    paths: PathMapper;
+    inputPath: string;
+    containerPath?: string;
+    expectedContent?: string;
+};
+export declare function waitForHostFile(hostPath: string, expectedContent?: string): Promise<void>;
+export declare function notifyHostLspAfterWrite(input: NotifyInput): Promise<string>;
+export declare function notifyHostLspAfterDelete(input: Omit<NotifyInput, 'expectedContent'>): Promise<string>;
+export declare function warmHostLspFile(input: Omit<NotifyInput, 'expectedContent'>): void;
+export {};

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

@@ -0,0 +1,78 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { logger } from '../logger.js';
+import { hostLspManager } from './manager.js';
+import { formatLspDiagnosticOutput, formatLspUnavailable, hasActionableDiagnostics } from './diagnostics.js';
+const HOST_SYNC_TIMEOUT_MS = 5000;
+const HOST_SYNC_INTERVAL_MS = 50;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function waitForHostFile(hostPath, expectedContent) {
+    const startedAt = Date.now();
+    let lastContent;
+    while (Date.now() - startedAt <= HOST_SYNC_TIMEOUT_MS) {
+        if (existsSync(hostPath)) {
+            if (expectedContent === undefined)
+                return;
+            try {
+                lastContent = await readFile(hostPath, 'utf8');
+                if (lastContent === expectedContent)
+                    return;
+            }
+            catch (error) {
+                void error;
+            }
+        }
+        await delay(HOST_SYNC_INTERVAL_MS);
+    }
+    if (expectedContent === undefined) {
+        throw new Error(`Timed out waiting for host file ${hostPath}`);
+    }
+    throw new Error(`Timed out waiting for host file ${hostPath} to match sandbox write (${lastContent?.length ?? 0}/${expectedContent.length} bytes visible)`);
+}
+export async function notifyHostLspAfterWrite(input) {
+    const hostPath = input.paths.toHost(input.containerPath ?? input.inputPath);
+    if (!input.paths.isMapped(hostPath))
+        return undefined;
+    try {
+        await waitForHostFile(hostPath, input.expectedContent);
+        await hostLspManager.touchFile({
+            sessionID: input.sessionID,
+            worktree: input.worktree,
+            filePath: hostPath,
+            diagnostics: 'document',
+        });
+        const diagnostics = hostLspManager.diagnosticsForFile({
+            sessionID: input.sessionID,
+            worktree: input.worktree,
+            filePath: hostPath,
+        });
+        if (!hasActionableDiagnostics(diagnostics))
+            return undefined;
+        return formatLspDiagnosticOutput(input.paths.toRelative(hostPath), diagnostics);
+    }
+    catch (error) {
+        return formatLspUnavailable(error);
+    }
+}
+export async function notifyHostLspAfterDelete(input) {
+    const hostPath = input.paths.toHost(input.containerPath ?? input.inputPath);
+    if (!input.paths.isMapped(hostPath))
+        return undefined;
+    try {
+        await hostLspManager.closeFile({ sessionID: input.sessionID, worktree: input.worktree, filePath: hostPath });
+        return undefined;
+    }
+    catch (error) {
+        return formatLspUnavailable(error);
+    }
+}
+export function warmHostLspFile(input) {
+    const hostPath = input.paths.toHost(input.containerPath ?? input.inputPath);
+    if (!input.paths.isMapped(hostPath))
+        return;
+    void hostLspManager
+        .touchFile({ sessionID: input.sessionID, worktree: input.worktree, filePath: hostPath })
+        .catch((error) => logger.warn(`[lsp] warm skipped for ${hostPath}: ${error?.message || error}`));
+}