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 console.error(`Prettier path argument was not specified or empty.\nUsage: ${process.argv[0]} ${process.argv[1]} prettier/path`);
9 process.exit(1);
10}
11fs.stat(prettierContainerPath, (err, stats) => {
12 if (err) {
13 console.error(`Path '${prettierContainerPath}' does not exist.`);
14 process.exit(1);
15 }
16
17 if (!stats.isDirectory()) {
18 console.log(`Path '${prettierContainerPath}' exists but is not a directory.`);
19 process.exit(1);
20 }
21});
22const prettierPath = path.join(prettierContainerPath, 'node_modules/prettier');
23
24
25(async () => {
26 let prettier;
27 try {
28 prettier = await loadPrettier(prettierPath);
29 } catch (error) {
30 console.error("Failed to load prettier: ", error);
31 process.exit(1);
32 }
33 console.log("Prettier loadded successfully.");
34 process.stdin.resume();
35 handleBuffer(prettier);
36})()
37
38async function handleBuffer(prettier) {
39 for await (let messageText of readStdin()) {
40 handleData(messageText, prettier).catch(e => {
41 console.error("Failed to handle formatter request", e);
42 });
43 }
44}
45
46async function* readStdin() {
47 let buffer = Buffer.alloc(0);
48 let streamEnded = false;
49 process.stdin.on('end', () => {
50 streamEnded = true;
51 });
52 process.stdin.on('data', (data) => {
53 buffer = Buffer.concat([buffer, data]);
54 });
55
56 async function handleStreamEnded(errorMessage) {
57 sendResponse(makeError(errorMessage));
58 buffer = Buffer.alloc(0);
59 messageLength = null;
60 await once(process.stdin, 'readable');
61 streamEnded = false;
62 }
63
64 try {
65 const headersSeparator = "\r\n\r\n";
66 let contentLengthHeaderName = 'Content-Length';
67 let headersLength = null;
68 let messageLength = null;
69 main_loop: while (true) {
70 if (messageLength === null) {
71 while (buffer.indexOf(headersSeparator) === -1) {
72 if (streamEnded) {
73 await handleStreamEnded('Unexpected end of stream: headers not found');
74 continue main_loop;
75 } else if (buffer.length > contentLengthHeaderName.length * 10) {
76 await handleStreamEnded(`Unexpected stream of bytes: no headers end found after ${buffer.length} bytes of input`);
77 continue main_loop;
78 }
79 await once(process.stdin, 'readable');
80 }
81 const headers = buffer.subarray(0, buffer.indexOf(headersSeparator)).toString('ascii');
82 const contentLengthHeader = headers.split('\r\n').map(header => header.split(': '))
83 .filter(header => header[2] === undefined)
84 .filter(header => (header[1] || '').length > 0)
85 .find(header => header[0].trim() === contentLengthHeaderName);
86 if (contentLengthHeader === undefined) {
87 await handleStreamEnded(`Missing or incorrect Content-Length header: ${headers}`);
88 continue main_loop;
89 }
90 headersLength = headers.length + headersSeparator.length;
91 messageLength = parseInt(contentLengthHeader[1], 10);
92 }
93
94 while (buffer.length < (headersLength + messageLength)) {
95 if (streamEnded) {
96 await handleStreamEnded(
97 `Unexpected end of stream: buffer length ${buffer.length} does not match expected header length ${headersLength} + body length ${messageLength}`);
98 continue main_loop;
99 }
100 await once(process.stdin, 'readable');
101 }
102
103 const messageEnd = headersLength + messageLength;
104 const message = buffer.subarray(headersLength, messageEnd);
105 buffer = buffer.subarray(messageEnd);
106 messageLength = null;
107 yield message.toString('utf8');
108 }
109 } catch (e) {
110 console.error(`Error reading stdin: ${e}`);
111 } finally {
112 process.stdin.off('data', () => { });
113 }
114}
115
116async function handleData(messageText, prettier) {
117 try {
118 const message = JSON.parse(messageText);
119 await handleMessage(prettier, message);
120 } catch (e) {
121 sendResponse(makeError(`Request JSON parse error: ${e}`));
122 }
123}
124
125// format
126// clear_cache
127//
128// shutdown
129// error
130
131async function handleMessage(prettier, message) {
132 // TODO kb handle message.method, message.params and message.id
133 console.log(`message: ${JSON.stringify(message)}`);
134 sendResponse({ method: "hi", result: null });
135}
136
137function makeError(message) {
138 return { method: "error", message };
139}
140
141function sendResponse(response) {
142 const message = Buffer.from(JSON.stringify(response));
143 const length = Buffer.alloc(4);
144 length.writeUInt32LE(message.length);
145 process.stdout.write(length);
146 process.stdout.write(message);
147}
148
149function loadPrettier(prettierPath) {
150 return new Promise((resolve, reject) => {
151 fs.access(prettierPath, fs.constants.F_OK, (err) => {
152 if (err) {
153 reject(`Path '${prettierPath}' does not exist.Error: ${err}`);
154 } else {
155 try {
156 resolve(require(prettierPath));
157 } catch (err) {
158 reject(`Error requiring prettier module from path '${prettierPath}'.Error: ${err}`);
159 }
160 }
161 });
162 });
163}