repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/lsp/__serial__/peer.ts
Rawimport { 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<Profile> {
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 } },
};
}