@intuned/runtime-dev 0.1.0-test.13 → 0.1.0-test.15

package/dist/commands/build.js

@@ -9,106 +9,72 @@ import json from "@rollup/plugin-json";
 import * as fs from "fs-extra";
 import * as path from "path";
 import { moveWebTemplateFiles } from "./common/utils/webTemplate.js";
+import { fileURLToPath } from "url";
 function isThirdPartyWarning(warning) {
-    if (warning.id && /node_modules/.test(warning.id))
-        return true;
-    if (warning.ids && warning.ids.every((id) => /node_modules/.test(id)))
-        return true;
-    return false;
+  if (warning.id && /node_modules/.test(warning.id)) return true;
+  if (warning.ids && warning.ids.every(id => /node_modules/.test(id))) return true;
+  return false;
 }
 import dotenv from "dotenv";
 dotenv.config();
-program
-    .description("build the intuned server")
-    .addArgument(new Argument("<mode>", "mode of execution")
-    .choices(["vanilla", "playwright"])
-    .default("playwright")
-    .argOptional())
-    .argument("[outfile]", "output bundle", "./output/bundle_v2.js")
-    .allowUnknownOption()
-    .action(async (mode, outfile) => {
-    await moveWebTemplateFiles();
-    const currentTemplateTsConfig = path.resolve(path.dirname(import.meta.url), "..", "..", "template.tsconfig.json");
-    await fs.copy(currentTemplateTsConfig, "./intuned/WebTemplate/tsconfig.json");
-    await build(outfile, mode);
+program.description("build the intuned server").addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright"]).default("playwright").argOptional()).argument("[outfile]", "output bundle", "./output/bundle_v2.js").allowUnknownOption().action(async (mode, outfile) => {
+  await moveWebTemplateFiles();
+  const currentTemplateTsConfig = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "template.tsconfig.json");
+  await fs.copy(currentTemplateTsConfig, "./intuned/WebTemplate/tsconfig.json");
+  await build(outfile, mode);
 });
 async function build(outfile, mode) {
-    let bundle = null;
-    let buildFailed = false;
-    try {
-        // create a bundle
-        bundle = await rollup({
-            input: `./intuned/WebTemplate/index.${mode}.ts`,
-            output: {
-                globals: { crypto: "crypto" },
-            },
-            plugins: [
-                json(),
-                nodeResolve({ exportConditions: ["node"], preferBuiltins: true }),
-                typescript({ tsconfig: "./intuned/WebTemplate/tsconfig.json" }),
-                commonjs({
-                    include: [
-                        "node_modules/**",
-                        "intuned/WebTemplate/**",
-                        "dist",
-                        "../typescript-sdk/**",
-                        "../typescript-runtime/**",
-                    ],
-                    extensions: [".js"],
-                    ignoreGlobal: false,
-                    sourceMap: false,
-                    dynamicRequireTargets: [
-                        // "api/**/*.ts",
-                        // "auth-sessions/**/*.ts",
-                        "api/**/*.js",
-                        "auth-sessions/**/*.js",
-                    ],
-                    requireReturnsDefault: "auto",
-                    transformMixedEsModules: true,
-                }),
-                dynamicImportVars({
-                    include: ["**/*.js", "**/*.ts"],
-                    exclude: ["**/*.d.ts", "**/*.js.map"],
-                }),
-            ],
-            onwarn: (warning, warn) => {
-                if (isThirdPartyWarning(warning))
-                    return;
-                warn(warning);
-            },
-            external: [
-                "@intuned/playwright",
-                "@intuned/playwright-core",
-                "@intuned/runtime",
-                "jsdom",
-                "canvas",
-                "pdfjs-dist",
-                "pdf-to-png-converter",
-                "crypto",
-                "applicationinsights",
-                "fingerprint-generator",
-                "fingerprint-injector",
-            ],
-        });
-        console.log(`📦 Building ${outfile}`);
-        const outfileFolder = path.dirname(outfile);
-        // copy assets to outfile folder
-        const assetsDir = path.resolve(path.dirname(import.meta.url), "..", "common", "assets");
-        await fs.copy(assetsDir, `${outfileFolder}/assets`);
-        await bundle.write({
-            format: "cjs",
-            file: outfile,
-            inlineDynamicImports: true,
-        });
-        console.log(`✨ Build succeeded: ${outfile}`);
-    }
-    catch (error) {
-        buildFailed = true;
-        console.error("error", error);
-    }
-    if (buildFailed) {
-        console.error("build failed");
-        process.exit(1);
-    }
+  let bundle = null;
+  let buildFailed = false;
+  try {
+    bundle = await rollup({
+      input: `./intuned/WebTemplate/index.${mode}.ts`,
+      output: {
+        globals: {
+          crypto: "crypto"
+        }
+      },
+      plugins: [json(), nodeResolve({
+        exportConditions: ["node"],
+        preferBuiltins: true
+      }), typescript({
+        tsconfig: "./intuned/WebTemplate/tsconfig.json",
+        exclude: ["**/*.d.ts"]
+      }), commonjs({
+        include: ["node_modules/**", "intuned/WebTemplate/**", "dist", "../typescript-sdk/**"],
+        extensions: [".js"],
+        ignoreGlobal: false,
+        sourceMap: false,
+        dynamicRequireTargets: ["api/**/*.js", "auth-sessions/**/*.js"],
+        requireReturnsDefault: "auto",
+        transformMixedEsModules: true
+      }), dynamicImportVars({
+        include: ["**/*.js"],
+        exclude: ["**/*.d.ts", "**/*.js.map"]
+      })],
+      onwarn: (warning, warn) => {
+        if (isThirdPartyWarning(warning)) return;
+        warn(warning);
+      },
+      external: ["@intuned/playwright", "@intuned/playwright-core", "jsdom", "canvas", "pdfjs-dist", "pdf-to-png-converter", "crypto", "applicationinsights", "fingerprint-generator", "fingerprint-injector"]
+    });
+    console.log(`📦 Building ${outfile}`);
+    const outfileFolder = path.dirname(outfile);
+    const assetsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "common", "assets");
+    await fs.copy(assetsDir, `${outfileFolder}/assets`);
+    await bundle.write({
+      format: "cjs",
+      file: outfile,
+      inlineDynamicImports: true
+    });
+    console.log(`✨ Build succeeded: ${outfile}`);
+  } catch (error) {
+    buildFailed = true;
+    console.error("error", error);
+  }
+  if (buildFailed) {
+    console.error("build failed");
+    process.exit(1);
+  }
 }
-program.parse(process.argv);
+program.parse(process.argv);

package/dist/commands/common/browserUtils.js

@@ -1,56 +1,45 @@
-// this file is to make testing easier only.
 import { spawn } from "child_process";
 import * as playwright from "@intuned/playwright-core";
 import * as fs from "fs-extra";
 import { getFullPathInProject } from "./utils/fileUtils.js";
 import { getContextStorageState } from "../../common/contextStorageStateHelpers";
 export const REMOTE_DEBUGGING_PORT = 9222;
-export const getChromiumLaunchArgs = () => [
-    "--no-sandbox",
-    `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`,
-    `--user-data-dir=/tmp/${Date.now()}`,
-    "--new-window",
-    "--start-maximized",
-    "--disable-popup-blocking",
-];
-// this is needed cause we need to keep the same browser instance alive between start recording and stop recording calls.
+export const getChromiumLaunchArgs = () => ["--no-sandbox", `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`, `--user-data-dir=/tmp/${Date.now()}`, "--new-window", "--start-maximized", "--disable-popup-blocking"];
 async function getBrowser() {
-    let playwrightBrowser = null;
-    try {
-        playwrightBrowser = await playwright.chromium.connectOverCDP(`http://localhost:${REMOTE_DEBUGGING_PORT}`);
-    }
-    catch (e) {
-        throw new Error("Browser is not running");
-    }
-    return playwrightBrowser;
+  let playwrightBrowser = null;
+  try {
+    playwrightBrowser = await playwright.chromium.connectOverCDP(`http://localhost:${REMOTE_DEBUGGING_PORT}`);
+  } catch (e) {
+    throw new Error("Browser is not running");
+  }
+  return playwrightBrowser;
 }
 export async function startOrRestartBrowser() {
-    const chromiumPath = await playwright.chromium.executablePath();
-    const chromeInstanceProcess = spawn(chromiumPath, getChromiumLaunchArgs());
-    chromeInstanceProcess.stdout.on("data", (data) => {
-        console.log(`Chrome stdout: ${data}`);
-    });
-    chromeInstanceProcess.stderr.on("data", (data) => {
-        console.error(`Chrome stderr: ${data}`);
-    });
+  const chromiumPath = await playwright.chromium.executablePath();
+  const chromeInstanceProcess = spawn(chromiumPath, getChromiumLaunchArgs());
+  chromeInstanceProcess.stdout.on("data", data => {
+    console.log(`Chrome stdout: ${data}`);
+  });
+  chromeInstanceProcess.stderr.on("data", data => {
+    console.error(`Chrome stderr: ${data}`);
+  });
 }
 export async function saveSessionFromOpenedBrowser(path) {
-    const browser = await getBrowser();
-    const context = await browser.contexts()[0];
-    return saveSession(path, context);
+  const browser = await getBrowser();
+  const context = await browser.contexts()[0];
+  return saveSession(path, context);
 }
 export async function loadState(path, context) {
-    const fullPath = getFullPathInProject(path);
-    if (!(await fs.pathExists(fullPath))) {
-        throw new Error("session file does not exist");
-    }
-    const data = await fs.readJson(fullPath);
-    await context.addCookies(data.cookies);
-    // ToDo: logic to load storage without using the page.
+  const fullPath = getFullPathInProject(path);
+  if (!(await fs.pathExists(fullPath))) {
+    throw new Error("session file does not exist");
+  }
+  const data = await fs.readJson(fullPath);
+  await context.addCookies(data.cookies);
 }
 export async function saveSession(path, context) {
-    const fullState = await getContextStorageState(context);
-    const fullPath = getFullPathInProject(path);
-    fs.ensureFileSync(fullPath);
-    await fs.writeJSON(fullPath, fullState);
-}
+  const fullState = await getContextStorageState(context);
+  const fullPath = getFullPathInProject(path);
+  fs.ensureFileSync(fullPath);
+  await fs.writeJSON(fullPath, fullState);
+}

package/dist/commands/common/getDefaultExportFromFile.d.ts

@@ -1 +0,0 @@
-export declare function getDefaultExportFromFile(apiFilePath: string): Promise<any>;

package/dist/commands/common/getDefaultExportFromFile.js

@@ -1,12 +0,0 @@
-export async function getDefaultExportFromFile(apiFilePath) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    require("ts-node").register({
-        transpileOnly: true,
-        compilerOptions: {
-            lib: ["dom", "es2020"],
-        },
-    });
-    const imported = await import(apiFilePath);
-    const defaultExport = imported.default;
-    return defaultExport;
-}

package/dist/commands/common/getFirstLineNumber.js

@@ -1,103 +1,96 @@
-import { ts, Project, ModuleKind, ScriptTarget, Node, } from "ts-morph";
+import { ts, Project, ModuleKind, ScriptTarget, Node } from "ts-morph";
 import { SourceMapConsumer } from "source-map";
 function compileTypeScript(apiFilePath) {
-    const compilerOptions = {
-        lib: ["dom", "es2020"],
-        sourceMap: true,
-        inlineSourceMap: true,
-        inlineSources: true,
-        declaration: false,
-        noEmit: false,
-        module: ModuleKind.CommonJS,
-        target: ScriptTarget.ES2020,
-    };
-    const project = new Project({
-        compilerOptions,
-    });
-    const sourceFile = project.addSourceFileAtPath(apiFilePath);
-    const outputJS = project.emitToMemory({ targetSourceFile: sourceFile });
-    const outputJSText = outputJS.getFiles()[0].text;
-    return { sourceFile, outputJSText };
+  const compilerOptions = {
+    lib: ["dom", "es2020"],
+    sourceMap: true,
+    inlineSourceMap: true,
+    inlineSources: true,
+    declaration: false,
+    noEmit: false,
+    module: ModuleKind.CommonJS,
+    target: ScriptTarget.ES2020
+  };
+  const project = new Project({
+    compilerOptions
+  });
+  const sourceFile = project.addSourceFileAtPath(apiFilePath);
+  const outputJS = project.emitToMemory({
+    targetSourceFile: sourceFile
+  });
+  const outputJSText = outputJS.getFiles()[0].text;
+  return {
+    sourceFile,
+    outputJSText
+  };
 }
 export function findFirstExecutableLine(sourceFile) {
-    let functionBody;
-    // Directly find the default exported function's body
-    const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
-    const defaultExportDeclaration = defaultExportSymbol?.getDeclarations()?.[0];
-    if (defaultExportDeclaration) {
-        // Check if the default export is a function
-        if (defaultExportDeclaration.getKind() === ts.SyntaxKind.FunctionDeclaration) {
-            functionBody = defaultExportDeclaration.getBody();
+  var _defaultExportSymbol$;
+  let functionBody;
+  const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
+  const defaultExportDeclaration = defaultExportSymbol === null || defaultExportSymbol === void 0 || (_defaultExportSymbol$ = defaultExportSymbol.getDeclarations()) === null || _defaultExportSymbol$ === void 0 ? void 0 : _defaultExportSymbol$[0];
+  if (defaultExportDeclaration) {
+    if (defaultExportDeclaration.getKind() === ts.SyntaxKind.FunctionDeclaration) {
+      functionBody = defaultExportDeclaration.getBody();
+    } else {
+      const exportAssignments = sourceFile.getExportAssignments();
+      for (const exportAssignment of exportAssignments) {
+        const expression = exportAssignment.getExpression();
+        if (!expression) continue;
+        if (expression.getKind() === ts.SyntaxKind.Identifier || expression.getKind() === ts.SyntaxKind.FunctionExpression || expression.getKind() === ts.SyntaxKind.ArrowFunction) {
+          var _sourceFile$getVariab;
+          const identifier = expression.getText();
+          const possiblyExportedFunction = sourceFile.getFunction(identifier) || ((_sourceFile$getVariab = sourceFile.getVariableStatement(identifier)) === null || _sourceFile$getVariab === void 0 ? void 0 : _sourceFile$getVariab.getDescendants().find(node => node.getKind() === ts.SyntaxKind.FunctionExpression || node.getKind() === ts.SyntaxKind.ArrowFunction));
+          if (possiblyExportedFunction) {
+            functionBody = possiblyExportedFunction.getBody();
+            break;
+          }
         }
-        else {
-            // Handle ExportAssignment specifically for cases like `export default identifier;`
-            const exportAssignments = sourceFile.getExportAssignments();
-            for (const exportAssignment of exportAssignments) {
-                const expression = exportAssignment.getExpression();
-                if (!expression)
-                    continue;
-                if (expression.getKind() === ts.SyntaxKind.Identifier ||
-                    expression.getKind() === ts.SyntaxKind.FunctionExpression ||
-                    expression.getKind() === ts.SyntaxKind.ArrowFunction) {
-                    const identifier = expression.getText();
-                    const possiblyExportedFunction = sourceFile.getFunction(identifier) ||
-                        sourceFile
-                            .getVariableStatement(identifier)
-                            ?.getDescendants()
-                            .find((node) => node.getKind() === ts.SyntaxKind.FunctionExpression ||
-                            node.getKind() === ts.SyntaxKind.ArrowFunction);
-                    if (possiblyExportedFunction) {
-                        functionBody = possiblyExportedFunction.getBody();
-                        break;
-                    }
-                }
-                if (Node.hasBody(expression) &&
-                    (expression.getKind() === ts.SyntaxKind.FunctionExpression ||
-                        expression.getKind() === ts.SyntaxKind.ArrowFunction)) {
-                    // As these are anonymous, we directly access their body
-                    functionBody = expression.getBody();
-                    break;
-                }
-            }
+        if (Node.hasBody(expression) && (expression.getKind() === ts.SyntaxKind.FunctionExpression || expression.getKind() === ts.SyntaxKind.ArrowFunction)) {
+          functionBody = expression.getBody();
+          break;
         }
+      }
     }
-    if (!functionBody || !Node.isStatemented(functionBody)) {
-        return -1;
-    }
-    if (functionBody.getStatements().length === 0) {
-        return -1;
-    }
-    const position = functionBody.getStatements()[0].getStart();
-    return sourceFile.getLineAndColumnAtPos(position);
+  }
+  if (!functionBody || !Node.isStatemented(functionBody)) {
+    return -1;
+  }
+  if (functionBody.getStatements().length === 0) {
+    return -1;
+  }
+  const position = functionBody.getStatements()[0].getStart();
+  return sourceFile.getLineAndColumnAtPos(position);
 }
 async function getSourceMap(jsCode) {
-    const sourceMapBase64 = jsCode.substring(jsCode.lastIndexOf("//# sourceMappingURL=data:application/json;base64,") +
-        "//# sourceMappingURL=data:application/json;base64,".length);
-    const sourceMapText = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
-    const sourceMap = JSON.parse(sourceMapText);
-    return new SourceMapConsumer(sourceMap);
+  const sourceMapBase64 = jsCode.substring(jsCode.lastIndexOf("//# sourceMappingURL=data:application/json;base64,") + "//# sourceMappingURL=data:application/json;base64,".length);
+  const sourceMapText = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
+  const sourceMap = JSON.parse(sourceMapText);
+  return new SourceMapConsumer(sourceMap);
 }
 async function mapFirstLineNumberBySourceMap(sourceFileName, jsCode, line, column) {
-    const sourceMap = await getSourceMap(jsCode);
-    const generatedLineNumber = sourceMap.generatedPositionFor({
-        source: sourceFileName,
-        line,
-        column,
-    }).line;
-    if (!generatedLineNumber)
-        return -1;
-    return generatedLineNumber;
+  const sourceMap = await getSourceMap(jsCode);
+  const generatedLineNumber = sourceMap.generatedPositionFor({
+    source: sourceFileName,
+    line,
+    column
+  }).line;
+  if (!generatedLineNumber) return -1;
+  return generatedLineNumber;
 }
 export default async function getFirstLineNumber(apiFilePath) {
-    const sourceFileName = apiFilePath.split("/").pop() ?? apiFilePath;
-    // Compile TypeScript to JavaScript and get the Typescript AST
-    const { sourceFile, outputJSText } = compileTypeScript(apiFilePath);
-    // Find the first line of code in the default export ts code
-    const result = findFirstExecutableLine(sourceFile);
-    if (result === -1)
-        return { sourceFileName, lineNumber: -1 };
-    return {
-        sourceFileName,
-        lineNumber: await mapFirstLineNumberBySourceMap(sourceFileName, outputJSText, result.line, result.column),
-    };
-}
+  const sourceFileName = apiFilePath.split("/").pop() ?? apiFilePath;
+  const {
+    sourceFile,
+    outputJSText
+  } = compileTypeScript(apiFilePath);
+  const result = findFirstExecutableLine(sourceFile);
+  if (result === -1) return {
+    sourceFileName,
+    lineNumber: -1
+  };
+  return {
+    sourceFileName,
+    lineNumber: await mapFirstLineNumberBySourceMap(sourceFileName, outputJSText, result.line, result.column)
+  };
+}

package/dist/commands/common/{getFirstLineNumber.test.ts → getFirstLineNumber.test.js}

@@ -2,8 +2,9 @@ import { expect, describe, it, beforeAll, afterAll } from "vitest";
 import getFirstLineNumber from "./getFirstLineNumber.js";
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
 describe("getFirstLineNumber", () => {
-  const testFilesDir = path.join(path.dirname(import.meta.url), "testFiles");
+  const testFilesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "testFiles");
   const createTestFile = (fileName, content) => {
     const filePath = path.join(testFilesDir, fileName);
     fs.writeFileSync(filePath, content);

package/dist/commands/common/sendMessageToClient.js

@@ -1,5 +1,3 @@
-// Send information to the parent process where it should continue the debugger
-// This is handled by DebuggingProcessManager
 export const sendBreakPointOnToClient = (sourceFileName, lineNumber) => {
-    console.log(`breakpoint on ${sourceFileName}:${lineNumber}`);
-};
+  console.log(`breakpoint on ${sourceFileName}:${lineNumber}`);
+};

package/dist/commands/common/utils/fileUtils.js

@@ -2,22 +2,22 @@ import * as path from "path";
 import * as fs from "fs-extra";
 import dotenv from "dotenv";
 dotenv.config();
-// TODO: todo-identity handle identity instances
 export function getFullPathInProject(...paths) {
-    return path.resolve(process.cwd(), process.env.ROOT || "./", ...paths);
+  return path.resolve(process.cwd(), process.env.ROOT || "./", ...paths);
 }
 export async function listProjectFilesAndFolders() {
-    const projectPath = path.resolve(process.cwd(), process.env.ROOT || "./");
-    try {
-        const files = await fs.readdir(projectPath, { withFileTypes: true });
-        return files.map((file) => ({
-            type: file.isDirectory() ? "Folder" : "File",
-            fullPath: path.join(projectPath, file.name),
-            name: file.name,
-        }));
-    }
-    catch (err) {
-        console.error("Error reading the directory:", err);
-        throw err;
-    }
-}
+  const projectPath = path.resolve(process.cwd(), process.env.ROOT || "./");
+  try {
+    const files = await fs.readdir(projectPath, {
+      withFileTypes: true
+    });
+    return files.map(file => ({
+      type: file.isDirectory() ? "Folder" : "File",
+      fullPath: path.join(projectPath, file.name),
+      name: file.name
+    }));
+  } catch (err) {
+    console.error("Error reading the directory:", err);
+    throw err;
+  }
+}

package/dist/commands/common/utils/settings.js

@@ -1,20 +1,22 @@
 import { getFullPathInProject } from "./fileUtils.js";
-import { settingsSchema, } from "../../../common/settingsSchema";
+import { settingsSchema } from "../../../common/settingsSchema";
 import { readJSON } from "fs-extra";
 export async function getSettings() {
-    const settingsFilePath = getFullPathInProject("Intuned.json");
-    console.log("loading settings");
-    const settings = await readJSON(settingsFilePath);
-    if (settings) {
-        const parsed = settingsSchema.safeParse(settings);
-        console.log(parsed);
-        if (parsed.success) {
-            return parsed.data;
-        }
-        else {
-            // ToDo: why does the type not work here?
-            throw new Error(parsed.error.message);
-        }
+  const settingsFilePath = getFullPathInProject("Intuned.json");
+  console.log("loading settings");
+  const settings = await readJSON(settingsFilePath);
+  if (settings) {
+    const parsed = settingsSchema.safeParse(settings);
+    console.log(parsed);
+    if (parsed.success) {
+      return parsed.data;
+    } else {
+      throw new Error(parsed.error.message);
     }
-    return { authSessions: { enabled: false } };
-}
+  }
+  return {
+    authSessions: {
+      enabled: false
+    }
+  };
+}

package/dist/commands/common/utils/unixSocket.js

@@ -1,45 +1,38 @@
 export class JSONUnixSocket {
-    constructor(socket) {
-        this.socket = socket;
+  static LENGTH_HEADER_LENGTH = 4;
+  constructor(socket) {
+    this.socket = socket;
+  }
+  sendJSON(data) {
+    const dataToSend = JSON.stringify(data);
+    const length = Buffer.byteLength(dataToSend);
+    const buffer = Buffer.alloc(JSONUnixSocket.LENGTH_HEADER_LENGTH + length);
+    buffer.writeUInt32BE(length, 0);
+    buffer.write(dataToSend, JSONUnixSocket.LENGTH_HEADER_LENGTH);
+    this.socket.write(buffer);
+  }
+  async *receiveJSON() {
+    let buffer = Buffer.alloc(0);
+    const endPromise = new Promise((resolve, reject) => {
+      this.socket.once("end", () => {
+        console.log("end");
+        resolve();
+      });
+      this.socket.once("error", reject);
+    });
+    while (true) {
+      const chunk = await Promise.race([new Promise(resolve => this.socket.once("data", data => resolve(data))), endPromise]);
+      if (!(chunk instanceof Buffer)) {
+        break;
+      }
+      buffer = Buffer.concat([buffer, chunk]);
+      const length = buffer.readUInt32BE(0);
+      if (buffer.length < length + JSONUnixSocket.LENGTH_HEADER_LENGTH) {
+        continue;
+      }
+      const data = buffer.subarray(JSONUnixSocket.LENGTH_HEADER_LENGTH, length + JSONUnixSocket.LENGTH_HEADER_LENGTH);
+      buffer = buffer.subarray(length + JSONUnixSocket.LENGTH_HEADER_LENGTH);
+      yield JSON.parse(data.toString());
     }
-    sendJSON(data) {
-        const dataToSend = JSON.stringify(data);
-        // calculate length
-        const length = Buffer.byteLength(dataToSend);
-        // create buffer
-        const buffer = Buffer.alloc(JSONUnixSocket.LENGTH_HEADER_LENGTH + length);
-        // write length in big endian
-        buffer.writeUInt32BE(length, 0);
-        // write data
-        buffer.write(dataToSend, JSONUnixSocket.LENGTH_HEADER_LENGTH);
-        this.socket.write(buffer);
-    }
-    async *receiveJSON() {
-        let buffer = Buffer.alloc(0);
-        const endPromise = new Promise((resolve, reject) => {
-            this.socket.once("end", () => {
-                console.log("end");
-                resolve();
-            });
-            this.socket.once("error", reject);
-        });
-        while (true) {
-            const chunk = await Promise.race([
-                new Promise((resolve) => this.socket.once("data", (data) => resolve(data))),
-                endPromise,
-            ]);
-            if (!(chunk instanceof Buffer)) {
-                break;
-            }
-            buffer = Buffer.concat([buffer, chunk]);
-            const length = buffer.readUInt32BE(0);
-            if (buffer.length < length + JSONUnixSocket.LENGTH_HEADER_LENGTH) {
-                continue;
-            }
-            const data = buffer.subarray(JSONUnixSocket.LENGTH_HEADER_LENGTH, length + JSONUnixSocket.LENGTH_HEADER_LENGTH);
-            buffer = buffer.subarray(length + JSONUnixSocket.LENGTH_HEADER_LENGTH);
-            yield JSON.parse(data.toString());
-        }
-    }
-}
-JSONUnixSocket.LENGTH_HEADER_LENGTH = 4;
+  }
+}