@intuned/runtime-dev 1.3.18-interface.13 → 1.3.18-interface.16

package/dist/runtime/persistentStore.d.ts

@@ -0,0 +1,2 @@
+import type { PersistentStore } from "./export";
+export declare const persistentStore: PersistentStore;

package/dist/runtime/persistentStore.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.persistentStore = void 0;
+var _zod = require("zod");
+var _jwtTokenManager = require("../common/jwtTokenManager");
+const forbiddenCharacters = /[:#]/g;
+const keySchema = _zod.z.string().min(1, "Key must be at least 1 character long").refine(key => (key.match(forbiddenCharacters)?.length ?? 0) === 0, 'Key cannot contain the following characters: ":" or "#"');
+const persistentStore = exports.persistentStore = Object.freeze({
+  get: async key => {
+    const parsedKey = keySchema.parse(key);
+    const response = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`kv-store/${parsedKey}`, {
+      method: "GET"
+    });
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+    return json.value;
+  },
+  set: async (key, value) => {
+    const keyResult = keySchema.parse(key);
+    const response = await (0, _jwtTokenManager.callBackendFunctionWithToken)(`kv-store/${keyResult}`, {
+      method: "PUT",
+      body: JSON.stringify(value),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+  }
+});

package/dist/runtime/persistentStore.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _zod = require("zod");
+var _persistentStore = require("./persistentStore");
+var _jwtTokenManager = require("../common/jwtTokenManager");
+_vitest.vi.mock("../common/jwtTokenManager", () => ({
+  callBackendFunctionWithToken: _vitest.vi.fn()
+}));
+(0, _vitest.describe)("Cache", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _vitest.describe)("get", () => {
+    (0, _vitest.it)("should return value when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({
+          value: "cached_data"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      const result = await _persistentStore.persistentStore.get("test_key");
+      (0, _vitest.expect)(result).toBe("cached_data");
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledWith("kv-store/test_key", {
+        method: "GET"
+      });
+      (0, _vitest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Cache miss"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("test_key")).rejects.toThrow("Cache miss");
+    });
+    (0, _vitest.it)("should throw error for empty key", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with colon", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("invalid:key")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with hash", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("invalid#key")).rejects.toThrow(_zod.ZodError);
+    });
+  });
+  (0, _vitest.describe)("set", () => {
+    (0, _vitest.it)("should call backend correctly when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      const testValue = {
+        data: "test"
+      };
+      await _persistentStore.persistentStore.set("test_key", testValue);
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledWith("kv-store/test_key", {
+        method: "PUT",
+        body: JSON.stringify(testValue),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      (0, _vitest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Set failed"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("test_key", "value")).rejects.toThrow("Set failed");
+    });
+    (0, _vitest.it)("should throw error for empty key", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("", "value")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with forbidden characters", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("invalid:key", "value")).rejects.toThrow(_zod.ZodError);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("invalid#key", "value")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should handle different value types", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await _persistentStore.persistentStore.set("key1", "string_value");
+      await _persistentStore.persistentStore.set("key2", {
+        object: "value"
+      });
+      await _persistentStore.persistentStore.set("key3", 123);
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledTimes(3);
+    });
+  });
+});

package/dist/runtime/runInfo.d.ts

@@ -0,0 +1,2 @@
+import { RunInfo } from "./export";
+export declare function runInfo(): RunInfo;

package/dist/runtime/runInfo.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runInfo = runInfo;
+var _asyncLocalStorage = require("../common/asyncLocalStorage");
+var _enums = require("./enums");
+function runInfo() {
+  const context = (0, _asyncLocalStorage.getExecutionContext)();
+  if (!context) {
+    return {
+      runEnvironment: _enums.RunEnvironment.IDE
+    };
+  }
+  const {
+    extendedPayloads: _extendedPayloads,
+    ...rest
+  } = context;
+  return rest;
+}

package/dist/vendor/runtime-interface.d.ts

@@ -0,0 +1 @@
+export * from '@intuned/runtime-interface';

package/dist/vendor/runtime-interface.js

@@ -0,0 +1,474 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../packages/runtime-interface/dist/errors.js
+var require_errors = __commonJS({
+  "../packages/runtime-interface/dist/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ResultTooBigError = exports2.InternalInvalidInputError = exports2.AutomationError = exports2.MaxLevelsExceededError = exports2.AuthCheckFailedError = exports2.AuthCheckNotFoundError = exports2.AuthRequiredError = exports2.AbortedError = exports2.InvalidCheckError = exports2.InvalidApiError = exports2.ApiNotFoundError = exports2.RunAutomationError = exports2.runAutomationErrorCodes = exports2.resultTooBigErrorCode = exports2.internalInvalidInputErrorCode = exports2.automationError = exports2.maxLevelsExceededErrorCode = exports2.authCheckFailedErrorCode = exports2.authCheckNotFoundErrorCode = exports2.authRequiredErrorCode = exports2.abortedErrorCode = exports2.invalidCheckErrorCode = exports2.invalidApiErrorCode = exports2.apiNotFoundErrorCode = void 0;
+    exports2.apiNotFoundErrorCode = "APINotFoundError";
+    exports2.invalidApiErrorCode = "InvalidAPIError";
+    exports2.invalidCheckErrorCode = "InvalidCheckError";
+    exports2.abortedErrorCode = "AbortedError";
+    exports2.authRequiredErrorCode = "AuthRequiredError";
+    exports2.authCheckNotFoundErrorCode = "AuthCheckNotFoundError";
+    exports2.authCheckFailedErrorCode = "AuthCheckFailedError";
+    exports2.maxLevelsExceededErrorCode = "MaxLevelsExceededError";
+    exports2.automationError = "AutomationError";
+    exports2.internalInvalidInputErrorCode = "InternalInvalidInputError";
+    exports2.resultTooBigErrorCode = "ResultTooBigError";
+    exports2.runAutomationErrorCodes = [
+      exports2.apiNotFoundErrorCode,
+      exports2.invalidApiErrorCode,
+      exports2.invalidCheckErrorCode,
+      exports2.abortedErrorCode,
+      exports2.authRequiredErrorCode,
+      exports2.authCheckNotFoundErrorCode,
+      exports2.authCheckFailedErrorCode,
+      exports2.maxLevelsExceededErrorCode,
+      exports2.automationError,
+      exports2.internalInvalidInputErrorCode,
+      exports2.resultTooBigErrorCode
+    ];
+    var RunAutomationError = class {
+      constructor(code, message) {
+        this.code = code;
+        this.message = message;
+      }
+      get json() {
+        return {
+          code: this.code,
+          details: this.details,
+          cause: this.cause?.json
+        };
+      }
+    };
+    exports2.RunAutomationError = RunAutomationError;
+    var ApiNotFoundError = class extends RunAutomationError {
+      constructor(apiName) {
+        super(exports2.apiNotFoundErrorCode, `API ${apiName} not found`);
+      }
+    };
+    exports2.ApiNotFoundError = ApiNotFoundError;
+    var InvalidApiError = class extends RunAutomationError {
+      constructor(message) {
+        super(exports2.invalidApiErrorCode, `API is invalid: ${message}`);
+        this.details = {
+          message
+        };
+      }
+    };
+    exports2.InvalidApiError = InvalidApiError;
+    var InvalidCheckError = class extends RunAutomationError {
+      constructor(message, cause) {
+        super(exports2.invalidCheckErrorCode, message);
+        this.cause = cause;
+      }
+    };
+    exports2.InvalidCheckError = InvalidCheckError;
+    var AbortedError = class extends RunAutomationError {
+      constructor() {
+        super(exports2.abortedErrorCode, "Operation was aborted");
+      }
+    };
+    exports2.AbortedError = AbortedError;
+    var AuthRequiredError = class extends RunAutomationError {
+      constructor() {
+        super(exports2.authRequiredErrorCode, "AuthSessions are required");
+      }
+    };
+    exports2.AuthRequiredError = AuthRequiredError;
+    var AuthCheckNotFoundError = class extends RunAutomationError {
+      constructor() {
+        super(exports2.authCheckNotFoundErrorCode, "AuthSession check not found");
+      }
+    };
+    exports2.AuthCheckNotFoundError = AuthCheckNotFoundError;
+    var AuthCheckFailedError = class extends RunAutomationError {
+      constructor() {
+        super(exports2.authCheckFailedErrorCode, "AuthSession check failed");
+      }
+    };
+    exports2.AuthCheckFailedError = AuthCheckFailedError;
+    var MaxLevelsExceededError = class extends RunAutomationError {
+      constructor(levels) {
+        super(exports2.maxLevelsExceededErrorCode, `Max levels exceeded. Only ${levels} levels are supported`);
+        this.details = { levels };
+      }
+    };
+    exports2.MaxLevelsExceededError = MaxLevelsExceededError;
+    var AutomationError = class extends RunAutomationError {
+      constructor(error) {
+        super(exports2.automationError, `[${error?.name ?? error}] ${error?.message}`);
+        this.details = {
+          ...error
+        };
+      }
+    };
+    exports2.AutomationError = AutomationError;
+    var InternalInvalidInputError = class extends RunAutomationError {
+      constructor(message, details) {
+        super(exports2.internalInvalidInputErrorCode, message);
+        this.details = details;
+      }
+    };
+    exports2.InternalInvalidInputError = InternalInvalidInputError;
+    var ResultTooBigError = class extends RunAutomationError {
+      constructor(sizeInBytes, maxSizeInBytes) {
+        super(exports2.resultTooBigErrorCode, `Automation result is too big. Size: ${Math.round(sizeInBytes / 1024 / 1024 * 100) / 100}MB, Max allowed: ${Math.round(maxSizeInBytes / 1024 / 1024 * 100) / 100}MB`);
+        this.details = { sizeInBytes, maxSizeInBytes };
+      }
+    };
+    exports2.ResultTooBigError = ResultTooBigError;
+  }
+});
+
+// ../packages/runtime-interface/dist/types.js
+var require_types = __commonJS({
+  "../packages/runtime-interface/dist/types.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.outputRunApiSchema = exports2.pongMessageSchema = exports2.doneMessageSchema = exports2.extendMessageSchema = exports2.runApiInputSchema = exports2.pingSchema = exports2.tokenUpdateSchema = exports2.abortRunApiSchema = exports2.startRunApiSchema = exports2.startRunApiParametersSchema = exports2.runApiParametersSchema = exports2.runApiRunOptionsSchema = exports2.runApiCdpRunOptionsSchema = exports2.runApiStandaloneRunOptionsSchema = exports2.runApiAuthSchema = exports2.runApiTracingSchema = exports2.runApiAutomationFunctionSchema = exports2.runApiSessionSchema = exports2.runApiStorageStateSchema = void 0;
+    exports2.runApiResultOkSchema = runApiResultOkSchema;
+    exports2.runApiResultWithSessionOkSchema = runApiResultWithSessionOkSchema;
+    var zod_1 = __importDefault(require("zod"));
+    exports2.runApiStorageStateSchema = zod_1.default.object({
+      cookies: zod_1.default.array(zod_1.default.object({
+        name: zod_1.default.string(),
+        value: zod_1.default.string(),
+        domain: zod_1.default.string(),
+        path: zod_1.default.string(),
+        expires: zod_1.default.number(),
+        httpOnly: zod_1.default.boolean(),
+        secure: zod_1.default.boolean(),
+        sameSite: zod_1.default.enum(["Strict", "Lax", "None"])
+      })),
+      origins: zod_1.default.array(zod_1.default.object({
+        origin: zod_1.default.string(),
+        localStorage: zod_1.default.array(zod_1.default.object({
+          name: zod_1.default.string(),
+          value: zod_1.default.string()
+        }))
+      })),
+      sessionStorage: zod_1.default.array(zod_1.default.object({
+        origin: zod_1.default.string(),
+        sessionStorage: zod_1.default.array(zod_1.default.object({
+          name: zod_1.default.string(),
+          value: zod_1.default.string()
+        }))
+      })).optional()
+    });
+    exports2.runApiSessionSchema = zod_1.default.discriminatedUnion("type", [
+      zod_1.default.object({
+        type: zod_1.default.literal("file"),
+        path: zod_1.default.string()
+      }),
+      zod_1.default.object({
+        type: zod_1.default.literal("state"),
+        state: exports2.runApiStorageStateSchema.nullable().optional()
+      })
+    ]);
+    exports2.runApiAutomationFunctionSchema = zod_1.default.object({
+      name: zod_1.default.string(),
+      params: zod_1.default.any().optional()
+    });
+    exports2.runApiTracingSchema = zod_1.default.discriminatedUnion("enabled", [
+      zod_1.default.object({ enabled: zod_1.default.literal(false) }),
+      zod_1.default.object({ enabled: zod_1.default.literal(true), filePath: zod_1.default.string() })
+    ]).optional().default({ enabled: false });
+    exports2.runApiAuthSchema = zod_1.default.object({
+      session: exports2.runApiSessionSchema,
+      parameters: zod_1.default.record(zod_1.default.any()).optional()
+    }).optional();
+    exports2.runApiStandaloneRunOptionsSchema = zod_1.default.object({
+      environment: zod_1.default.literal("standalone"),
+      headless: zod_1.default.boolean().default(true),
+      proxy: zod_1.default.object({
+        server: zod_1.default.string(),
+        username: zod_1.default.string(),
+        password: zod_1.default.string()
+      }).optional()
+    });
+    exports2.runApiCdpRunOptionsSchema = zod_1.default.object({
+      environment: zod_1.default.literal("cdp"),
+      cdpAddress: zod_1.default.string(),
+      cdpTargetId: zod_1.default.string().optional()
+    });
+    exports2.runApiRunOptionsSchema = zod_1.default.discriminatedUnion("environment", [
+      exports2.runApiStandaloneRunOptionsSchema,
+      exports2.runApiCdpRunOptionsSchema
+    ]).default({ environment: "standalone", headless: true });
+    exports2.runApiParametersSchema = zod_1.default.object({
+      automationFunction: exports2.runApiAutomationFunctionSchema,
+      tracing: exports2.runApiTracingSchema,
+      auth: exports2.runApiAuthSchema,
+      runOptions: exports2.runApiRunOptionsSchema,
+      retrieveSession: zod_1.default.boolean().default(false)
+    });
+    function runApiResultOkSchema(resultSchema) {
+      return zod_1.default.object({
+        result: resultSchema,
+        extendedPayloads: zod_1.default.array(zod_1.default.object({
+          api: zod_1.default.string(),
+          parameters: zod_1.default.record(zod_1.default.any())
+        })).optional()
+      });
+    }
+    function runApiResultWithSessionOkSchema(resultSchema) {
+      return runApiResultOkSchema(resultSchema).extend({
+        session: exports2.runApiStorageStateSchema
+      });
+    }
+    exports2.startRunApiParametersSchema = exports2.runApiParametersSchema.extend({
+      retrieveSession: zod_1.default.boolean(),
+      functionsToken: zod_1.default.string().optional(),
+      context: zod_1.default.object({
+        jobId: zod_1.default.string().optional(),
+        jobRunId: zod_1.default.string().optional(),
+        runId: zod_1.default.string().optional(),
+        queueId: zod_1.default.string().optional(),
+        authSessionId: zod_1.default.string().optional()
+      }).optional()
+    });
+    exports2.startRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("start"),
+      parameters: exports2.startRunApiParametersSchema
+    });
+    exports2.abortRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("abort"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports2.tokenUpdateSchema = zod_1.default.object({
+      type: zod_1.default.literal("tokenUpdate"),
+      parameters: zod_1.default.object({
+        functionsToken: zod_1.default.string()
+      })
+    });
+    exports2.pingSchema = zod_1.default.object({
+      type: zod_1.default.literal("ping"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports2.runApiInputSchema = zod_1.default.union([
+      exports2.startRunApiSchema,
+      exports2.abortRunApiSchema,
+      exports2.tokenUpdateSchema,
+      exports2.pingSchema
+    ]);
+    exports2.extendMessageSchema = zod_1.default.object({ type: zod_1.default.literal("extend") });
+    exports2.doneMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("done"),
+      result: zod_1.default.any(),
+      success: zod_1.default.boolean()
+    });
+    exports2.pongMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("pong")
+    });
+    exports2.outputRunApiSchema = zod_1.default.union([
+      exports2.extendMessageSchema,
+      exports2.doneMessageSchema,
+      exports2.pongMessageSchema
+    ]);
+  }
+});
+
+// ../packages/runtime-interface/dist/interfaceClient.js
+var require_interfaceClient = __commonJS({
+  "../packages/runtime-interface/dist/interfaceClient.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JSONLFileClient = exports2.TCPSocketClient = exports2.UnixSocketClient = exports2.SocketClient = void 0;
+    var net = __importStar(require("net"));
+    var fs = __importStar(require("fs-extra"));
+    var readline_1 = require("readline");
+    var promises_1 = require("timers/promises");
+    var SocketClient = class _SocketClient {
+      constructor(socket) {
+        this.socket = socket;
+      }
+      sendJSON(data) {
+        const dataToSend = JSON.stringify(data);
+        const length = Buffer.byteLength(dataToSend);
+        const buffer = Buffer.alloc(_SocketClient.LENGTH_HEADER_LENGTH + length);
+        buffer.writeUInt32BE(length, 0);
+        buffer.write(dataToSend, _SocketClient.LENGTH_HEADER_LENGTH);
+        this.socket.write(buffer);
+      }
+      async *receiveJSON() {
+        let buffer = Buffer.alloc(0);
+        const endPromise = new Promise((resolve, reject) => {
+          this.socket.once("end", () => {
+            resolve();
+          });
+          this.socket.once("error", reject);
+        });
+        while (true) {
+          const chunk = await Promise.race([
+            new Promise((resolve) => this.socket.once("data", (data2) => {
+              if (typeof data2 === "string") {
+                return resolve(Buffer.from(data2));
+              }
+              resolve(data2);
+            })),
+            endPromise
+          ]);
+          if (!(chunk instanceof Buffer)) {
+            break;
+          }
+          buffer = Buffer.concat([buffer, chunk]);
+          const length = buffer.readUInt32BE(0);
+          if (buffer.length < length + _SocketClient.LENGTH_HEADER_LENGTH) {
+            continue;
+          }
+          const data = buffer.subarray(_SocketClient.LENGTH_HEADER_LENGTH, length + _SocketClient.LENGTH_HEADER_LENGTH);
+          buffer = buffer.subarray(length + _SocketClient.LENGTH_HEADER_LENGTH);
+          yield JSON.parse(data.toString());
+        }
+      }
+      async close() {
+        this.socket.end();
+        await Promise.race([
+          new Promise((resolve) => this.socket.once("close", resolve)),
+          new Promise((resolve) => this.socket.once("error", resolve)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.socket.closed;
+      }
+    };
+    exports2.SocketClient = SocketClient;
+    SocketClient.LENGTH_HEADER_LENGTH = 4;
+    var UnixSocketClient = class extends SocketClient {
+      constructor(path) {
+        super(net.createConnection(path));
+      }
+    };
+    exports2.UnixSocketClient = UnixSocketClient;
+    var TCPSocketClient = class extends SocketClient {
+      constructor(host, port) {
+        super(net.createConnection(port, host));
+      }
+    };
+    exports2.TCPSocketClient = TCPSocketClient;
+    var JSONLFileClient = class {
+      constructor(filePath) {
+        this.fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
+      }
+      sendJSON(data) {
+        console.log("Sending message", data);
+      }
+      async *receiveJSON() {
+        const rl = (0, readline_1.createInterface)({
+          input: this.fileStream,
+          crlfDelay: Infinity
+        });
+        for await (const line of rl) {
+          if (line.trim() === "") {
+            continue;
+          }
+          yield JSON.parse(line);
+        }
+      }
+      async close() {
+        this.fileStream.close();
+        await Promise.race([
+          new Promise((resolve) => this.fileStream.once("close", resolve)),
+          new Promise((resolve) => this.fileStream.once("error", resolve)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.fileStream.closed;
+      }
+    };
+    exports2.JSONLFileClient = JSONLFileClient;
+  }
+});
+
+// ../packages/runtime-interface/dist/index.js
+var require_dist = __commonJS({
+  "../packages/runtime-interface/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_errors(), exports2);
+    __exportStar(require_types(), exports2);
+    __exportStar(require_interfaceClient(), exports2);
+  }
+});
+
+// src/vendor/runtime-interface.ts
+var runtime_interface_exports = {};
+module.exports = __toCommonJS(runtime_interface_exports);
+__reExport(runtime_interface_exports, __toESM(require_dist()), module.exports);