tenant.openagents/omega

1const { Buffer } = require("buffer");
2const fs = require("fs");
3const path = require("path");
4const { once } = require("events");
5
6const prettierContainerPath = process.argv[2];
7if (prettierContainerPath == null || prettierContainerPath.length == 0) {
8  process.stderr.write(
9    `Prettier path argument was not specified or empty.\nUsage: ${process.argv[0]} ${process.argv[1]} prettier/path\n`,
10  );
11  process.exit(1);
12}
13fs.stat(prettierContainerPath, (err, stats) => {
14  if (err) {
15    process.stderr.write(`Path '${prettierContainerPath}' does not exist\n`);
16    process.exit(1);
17  }
18
19  if (!stats.isDirectory()) {
20    process.stderr.write(`Path '${prettierContainerPath}' exists but is not a directory\n`);
21    process.exit(1);
22  }
23});
24const prettierPath = path.join(prettierContainerPath, "node_modules/prettier");
25
26class Prettier {
27  constructor(path, prettier, config) {
28    this.path = path;
29    this.prettier = prettier;
30    this.config = config;
31  }
32}
33
34(async () => {
35  let prettier;
36  let config;
37  try {
38    prettier = await loadPrettier(prettierPath);
39    config = (await prettier.resolveConfig(prettierPath)) || {};
40  } catch (e) {
41    process.stderr.write(`Failed to load prettier: ${e}\n`);
42    process.exit(1);
43  }
44  process.stderr.write(`Prettier at path '${prettierPath}' loaded successfully, config: ${JSON.stringify(config)}\n`);
45  process.stdin.resume();
46  handleBuffer(new Prettier(prettierPath, prettier, config));
47})();
48
49async function handleBuffer(prettier) {
50  for await (const messageText of readStdin()) {
51    let message;
52    try {
53      message = JSON.parse(messageText);
54    } catch (e) {
55      sendResponse(makeError(`Parse error in request message: ${e}\nMessage: ${messageText}`));
56      continue;
57    }
58    // allow concurrent request handling by not `await`ing the message handling promise (async function)
59    handleMessage(message, prettier).catch((e) => {
60      if ((message.params || {}).text !== undefined) {
61        message.params.text = "..snip..";
62      }
63      sendResponse({
64        id: message.id,
65        ...makeError(`${e}\nWhile handling prettier request: ${JSON.stringify(message)}`),
66      });
67    });
68  }
69}
70
71const headerSeparator = "\r\n";
72const contentLengthHeaderName = "Content-Length";
73
74async function* readStdin() {
75  let buffer = Buffer.alloc(0);
76  let streamEnded = false;
77  process.stdin.on("end", () => {
78    streamEnded = true;
79  });
80  process.stdin.on("data", (data) => {
81    buffer = Buffer.concat([buffer, data]);
82  });
83
84  async function handleStreamEnded(errorMessage) {
85    sendResponse(makeError(errorMessage));
86    buffer = Buffer.alloc(0);
87    messageLength = null;
88    await once(process.stdin, "readable");
89    streamEnded = false;
90  }
91
92  try {
93    let headersLength = null;
94    let messageLength = null;
95    main_loop: while (true) {
96      if (messageLength === null) {
97        while (buffer.indexOf(`${headerSeparator}${headerSeparator}`) === -1) {
98          if (streamEnded) {
99            await handleStreamEnded("Unexpected end of stream: headers not found");
100            continue main_loop;
101          } else if (buffer.length > contentLengthHeaderName.length * 10) {
102            await handleStreamEnded(
103              `Unexpected stream of bytes: no headers end found after ${buffer.length} bytes of input`,
104            );
105            continue main_loop;
106          }
107          await once(process.stdin, "readable");
108        }
109        const headers = buffer.subarray(0, buffer.indexOf(`${headerSeparator}${headerSeparator}`)).toString("ascii");
110        const contentLengthHeader = headers
111          .split(headerSeparator)
112          .map((header) => header.split(":"))
113          .filter((header) => header[2] === undefined)
114          .filter((header) => (header[1] || "").length > 0)
115          .find((header) => (header[0] || "").trim() === contentLengthHeaderName);
116        const contentLength = (contentLengthHeader || [])[1];
117        if (contentLength === undefined) {
118          await handleStreamEnded(`Missing or incorrect ${contentLengthHeaderName} header: ${headers}`);
119          continue main_loop;
120        }
121        headersLength = headers.length + headerSeparator.length * 2;
122        messageLength = parseInt(contentLength, 10);
123      }
124
125      while (buffer.length < headersLength + messageLength) {
126        if (streamEnded) {
127          await handleStreamEnded(
128            `Unexpected end of stream: buffer length ${buffer.length} does not match expected header length ${headersLength} + body length ${messageLength}`,
129          );
130          continue main_loop;
131        }
132        await once(process.stdin, "readable");
133      }
134
135      const messageEnd = headersLength + messageLength;
136      const message = buffer.subarray(headersLength, messageEnd);
137      buffer = buffer.subarray(messageEnd);
138      headersLength = null;
139      messageLength = null;
140      yield message.toString("utf8");
141    }
142  } catch (e) {
143    sendResponse(makeError(`Error reading stdin: ${e}`));
144  } finally {
145    process.stdin.off("data", () => {});
146  }
147}
148
149async function handleMessage(message, prettier) {
150  const { method, id, params } = message;
151  if (method === undefined) {
152    throw new Error(`Message method is undefined: ${JSON.stringify(message)}`);
153  } else if (method == "initialized") {
154    return;
155  } else if (method === "shutdown") {
156    sendResponse({ result: {} });
157  } else if (method == "exit") {
158    process.exit(0);
159  }
160
161  if (id === undefined) {
162    throw new Error(`Message id is undefined: ${JSON.stringify(message)}`);
163  }
164
165  if (method === "prettier/format") {
166    if (params === undefined || params.text === undefined) {
167      throw new Error(`Message params.text is undefined: ${JSON.stringify(message)}`);
168    }
169    if (params.options === undefined) {
170      throw new Error(`Message params.options is undefined: ${JSON.stringify(message)}`);
171    }
172
173    let resolvedConfig = {};
174    if (params.options.filepath) {
175      resolvedConfig = (await prettier.prettier.resolveConfig(params.options.filepath, { editorconfig: true })) || {};
176
177      if (params.options.ignorePath) {
178        const fileInfo = await prettier.prettier.getFileInfo(params.options.filepath, {
179          ignorePath: params.options.ignorePath,
180        });
181        if (fileInfo.ignored) {
182          process.stderr.write(
183            `Ignoring file '${params.options.filepath}' based on rules in '${params.options.ignorePath}'\n`,
184          );
185          sendResponse({ id, result: { text: params.text } });
186          return;
187        }
188      }
189    }
190
191    // Marking the params.options.filepath as undefined makes
192    // prettier.format() work even if no filepath is set.
193    if (params.options.filepath === null) {
194      params.options.filepath = undefined;
195    }
196
197    const plugins =
198      Array.isArray(resolvedConfig?.plugins) && resolvedConfig.plugins.length > 0
199        ? resolvedConfig.plugins
200        : params.options.plugins;
201
202    const rangeOptions = {};
203    if (params.options.rangeStart != null) {
204      rangeOptions.rangeStart = params.options.rangeStart;
205    }
206    if (params.options.rangeEnd != null) {
207      rangeOptions.rangeEnd = params.options.rangeEnd;
208    }
209
210    const options = {
211      ...(params.options.prettierOptions || prettier.config),
212      ...resolvedConfig,
213      plugins,
214      parser: params.options.parser,
215      filepath: params.options.filepath,
216      ...rangeOptions
217    };
218    process.stderr.write(
219      `Resolved config: ${JSON.stringify(resolvedConfig)}, will format file '${
220        params.options.filepath || ""
221      }' with options: ${JSON.stringify(options)}\n`,
222    );
223    const formattedText = await prettier.prettier.format(params.text, options);
224    sendResponse({ id, result: { text: formattedText } });
225  } else if (method === "prettier/clear_cache") {
226    prettier.prettier.clearConfigCache();
227    prettier.config = (await prettier.prettier.resolveConfig(prettier.path)) || {};
228    sendResponse({ id, result: null });
229  } else if (method === "initialize") {
230    sendResponse({
231      id,
232      result: {
233        capabilities: {},
234      },
235    });
236  } else {
237    throw new Error(`Unknown method: ${method}`);
238  }
239}
240
241function makeError(message) {
242  return {
243    error: {
244      code: -32600, // invalid request code
245      message,
246    },
247  };
248}
249
250function sendResponse(response) {
251  const responsePayloadString = JSON.stringify({
252    jsonrpc: "2.0",
253    ...response,
254  });
255  const headers = `${contentLengthHeaderName}: ${Buffer.byteLength(
256    responsePayloadString,
257  )}${headerSeparator}${headerSeparator}`;
258  process.stdout.write(headers + responsePayloadString);
259}
260
261function loadPrettier(prettierPath) {
262  return new Promise((resolve, reject) => {
263    fs.access(prettierPath, fs.constants.F_OK, (err) => {
264      if (err) {
265        reject(`Path '${prettierPath}' does not exist.Error: ${err}`);
266      } else {
267        try {
268          resolve(require(prettierPath));
269        } catch (err) {
270          reject(`Error requiring prettier module from path '${prettierPath}'.Error: ${err}`);
271        }
272      }
273    });
274  });
275}
276