import { writeFile } from "node:fs/promises"; import { join } from "node:path"; import type { Profile } from "../src/registry.ts"; export async function peer( directory: string, mode = "normal", extension: ".go" | ".ts" = ".go", ): Promise { const file = join(directory, `peer-${mode}.mjs`); const protocol = import.meta.resolve( "vscode-languageserver-protocol/node.js", ); await writeFile( file, ` import { createProtocolConnection, InitializeRequest, InitializedNotification, ConfigurationRequest, ApplyWorkspaceEditRequest, RegistrationRequest, DidOpenTextDocumentNotification, DidChangeTextDocumentNotification, DidChangeWatchedFilesNotification, HoverRequest, DefinitionRequest, TypeDefinitionRequest, ImplementationRequest, ReferencesRequest, ShutdownRequest, ExitNotification, ResponseError } from ${JSON.stringify(protocol)}; import { appendFileSync } from "node:fs"; import { join } from "node:path"; const mode = ${JSON.stringify(mode)}; appendFileSync(join(process.cwd(), ".peer-processes.jsonl"), JSON.stringify({ pid: process.pid, mode }) + "\\n"); const connection = createProtocolConnection(process.stdin, process.stdout); let documents = new Map(), changes = [], configuration, denied, registered, rootUri, commandDenied; connection.onRequest(InitializeRequest.type, async (params) => { rootUri = params.rootUri; if (mode === "init-hang") return new Promise(() => {}); if (mode === "flood") { process.stdout.write(Buffer.alloc(17 * 1024 * 1024, 65)); return new Promise(() => {}); } if (mode === "partial") { process.stdout.write("Content-Length: 500\\r\\n\\r\\n{"); return new Promise(() => {}); } return { capabilities: { positionEncoding: "utf-16", textDocumentSync: { openClose: true, change: 2 }, definitionProvider: mode !== "unsupported", referencesProvider: true, hoverProvider: true, typeDefinitionProvider: mode !== "unsupported", implementationProvider: mode !== "unsupported", callHierarchyProvider: mode !== "unsupported", documentSymbolProvider: mode !== "unsupported", workspaceSymbolProvider: mode !== "unsupported" && { resolveProvider: true } } }; }); connection.onNotification(InitializedNotification.type, async () => { configuration = await connection.sendRequest(ConfigurationRequest.type, { items: [{ section: "gopls" }] }); denied = await connection.sendRequest(ApplyWorkspaceEditRequest.type, { edit: { changes: { [rootUri + "/main${extension}"]: [{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }, newText: "UNAUTHORIZED_EDIT" }] } } }); try { await connection.sendRequest("workspace/executeCommand", { command: "UNAUTHORIZED_COMMAND", arguments: [] }); commandDenied = false; } catch (error) { commandDenied = error.code === -32601; } try { await connection.sendRequest(RegistrationRequest.type, { registrations: [{ id: "watch", method: "workspace/didChangeWatchedFiles", registerOptions: { watchers: [{ globPattern: "**/*${extension}" }] } }] }); registered = true; } catch (error) { registered = false; } }); connection.onNotification(DidOpenTextDocumentNotification.type, ({textDocument}) => documents.set(textDocument.uri, { text: textDocument.text, version: textDocument.version })); connection.onNotification(DidChangeTextDocumentNotification.type, ({textDocument, contentChanges}) => documents.set(textDocument.uri, { text: contentChanges[0].text, version: textDocument.version })); connection.onNotification(DidChangeWatchedFilesNotification.type, (params) => changes.push(...params.changes)); connection.onRequest(HoverRequest.type, async () => { // Ensure server-initiated request handlers have settled without a protocol barrier claim. for (let i = 0; i < 100 && (registered === undefined || commandDenied === undefined); i++) await new Promise(r => setTimeout(r, 1)); return { contents: JSON.stringify({ pid: process.pid, mode, configuration, denied, registered, commandDenied, documents: [...documents], changes }) }; }); connection.onRequest(DefinitionRequest.type, async (params) => { if (mode === "error") throw new ResponseError(0, "application failure"); if (mode === "malformed") return { invalid: true }; if (mode === "delay") await new Promise(r => setTimeout(r, 200)); return { uri: params.textDocument.uri, range: { start: params.position, end: params.position } }; }); for (const type of [TypeDefinitionRequest.type, ImplementationRequest.type]) connection.onRequest(type, params => [{ targetUri: params.textDocument.uri, targetRange: { start: params.position, end: params.position }, targetSelectionRange: { start: params.position, end: params.position } }]); const range = {start:{line:1,character:4},end:{line:1,character:9}}; connection.onRequest("textDocument/documentSymbol", async params => { if (mode === "delay") await new Promise(r => setTimeout(r,200)); return mode === "malformed" ? [{}] : mode === "flat" ? [{name:"Value",kind:13,containerName:"Fixture",location:{uri:params.textDocument.uri,range}}] : [{name:"Fixture",kind:3,range,selectionRange:range,children:[{name:"Value",kind:13,range,selectionRange:range}]}]; }); connection.onRequest("workspace/symbol", () => mode === "malformed" ? [{}] : [{name:"Value",kind:13,containerName:"Fixture",location:{uri:rootUri+"/main${extension}"},data:{secret:"preserved"}}]); connection.onRequest("workspaceSymbol/resolve", item => {if(item.data.secret !== "preserved") throw new Error("lost data"); return {...item,location:{...item.location,range}};}); connection.onRequest("textDocument/prepareCallHierarchy", params => { if (mode === "malformed") return [{}]; if (mode === "prepare-empty") return []; const item = {name:"Value",kind:12,uri:params.textDocument.uri,range,selectionRange:range,data:{opaque:{mode}}}; return mode.startsWith("ambiguous") ? [item,{...item,uri:mode === "ambiguous-cross" ? rootUri+"/nested/other${extension}" : item.uri,name:"Other",data:{opaque:{mode,second:true}}}] : [item]; }); for (const direction of ["incoming","outgoing"]) connection.onRequest("callHierarchy/"+direction+"Calls", async ({item}) => { if (item.data.opaque.mode !== mode) throw new Error("lost prepared metadata"); if (mode === "delay") await new Promise(r => setTimeout(r,200)); if (mode === "calls-empty") return []; const target = {...item,uri:rootUri+"/other${extension}",name:"Other"}; return [{[direction === "incoming" ? "from" : "to"]:target,fromRanges:[range]}]; }); connection.onRequest(ReferencesRequest.type, () => []); connection.onRequest(ShutdownRequest.type, () => mode === "stubborn" ? new Promise(() => {}) : null); connection.onNotification(ExitNotification.type, () => { if (mode !== "stubborn") process.exit(0); }); if (mode === "stubborn") { process.on("SIGTERM", () => {}); setInterval(() => {}, 1000); } connection.listen(); `, ); return { id: "peer", command: process.execPath, args: [file], language: "go", initializationOptions: {}, settings: { gopls: { marker: mode } }, }; }