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

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

@@ -1,38 +1,45 @@
 export class JSONUnixSocket {
-  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());
+    constructor(socket) {
+        this.socket = socket;
     }
-  }
-}
+    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;

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

@@ -0,0 +1,38 @@
+export class JSONUnixSocket {
+  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());
+    }
+  }
+}

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

@@ -1,22 +1,29 @@
 import * as fs from "fs-extra";
 import * as path from "path";
-import { getFullPathInProject, listProjectFilesAndFolders } from "./fileUtils";
+import { getFullPathInProject, listProjectFilesAndFolders, } from "./fileUtils.js";
 export const moveWebTemplateFiles = async () => {
-  await fs.remove("./intuned");
-  await fs.ensureDir("./intuned");
-  const currentFileLocation = path.resolve(__dirname, "..", "..", "..", "..", "WebTemplate");
-  await fs.copy(`${currentFileLocation}`, "./intuned/WebTemplate", {
-    filter: (src, dest) => {
-      if (src.includes(".d.ts")) {
-        return false;
-      }
-      return true;
+    await fs.remove("./intuned");
+    await fs.ensureDir("./intuned");
+    const currentFileLocation = path.resolve(path.dirname(import.meta.url), "..", "..", "..", "..", "WebTemplate");
+    // copy WebTemplate to ./intuned
+    await fs.copy(`${currentFileLocation}`, "./intuned/WebTemplate", {
+        filter: (src, dest) => {
+            if (src.includes(".d.ts")) {
+                return false;
+            }
+            return true;
+        },
+    });
+    const filesAndFolders = await listProjectFilesAndFolders();
+    const pathsIgnoreList = [
+        getFullPathInProject("intuned"),
+        getFullPathInProject("node_modules"),
+        getFullPathInProject("package.json"),
+        getFullPathInProject("yarn.lock"),
+        getFullPathInProject(".env"),
+    ];
+    const filesToCopy = filesAndFolders.filter((file) => !pathsIgnoreList.includes(file.fullPath));
+    for (const file of filesToCopy) {
+        await fs.copy(file.fullPath, `./intuned/WebTemplate/${file.name}`);
     }
-  });
-  const filesAndFolders = await listProjectFilesAndFolders();
-  const pathsIgnoreList = [getFullPathInProject("intuned"), getFullPathInProject("node_modules"), getFullPathInProject("package.json"), getFullPathInProject("yarn.lock"), getFullPathInProject(".env")];
-  const filesToCopy = filesAndFolders.filter(file => !pathsIgnoreList.includes(file.fullPath));
-  for (const file of filesToCopy) {
-    await fs.copy(file.fullPath, `./intuned/WebTemplate/${file.name}`);
-  }
-};
+};

package/dist/commands/common/utils/webTemplate.ts

@@ -0,0 +1,22 @@
+import * as fs from "fs-extra";
+import * as path from "path";
+import { getFullPathInProject, listProjectFilesAndFolders } from "./fileUtils.js";
+export const moveWebTemplateFiles = async () => {
+  await fs.remove("./intuned");
+  await fs.ensureDir("./intuned");
+  const currentFileLocation = path.resolve(path.dirname(import.meta.url), "..", "..", "..", "..", "WebTemplate");
+  await fs.copy(`${currentFileLocation}`, "./intuned/WebTemplate", {
+    filter: (src, dest) => {
+      if (src.includes(".d.ts")) {
+        return false;
+      }
+      return true;
+    }
+  });
+  const filesAndFolders = await listProjectFilesAndFolders();
+  const pathsIgnoreList = [getFullPathInProject("intuned"), getFullPathInProject("node_modules"), getFullPathInProject("package.json"), getFullPathInProject("yarn.lock"), getFullPathInProject(".env")];
+  const filesToCopy = filesAndFolders.filter(file => !pathsIgnoreList.includes(file.fullPath));
+  for (const file of filesToCopy) {
+    await fs.copy(file.fullPath, `./intuned/WebTemplate/${file.name}`);
+  }
+};

package/dist/commands/interface/run.js

@@ -1,156 +1,162 @@
 #!/usr/bin/env node
 import { program } from "commander";
 import dotenv from "dotenv";
-import { runWithContext } from "../../common/asyncLocalStorage";
+import { runWithContext, } from "../../common/asyncLocalStorage";
 import * as net from "net";
 import z from "zod";
-import { runApiGenerator, runApiParametersSchema } from "../../common/runApi";
+import { runApiGenerator, runApiParametersSchema, } from "../../common/runApi";
 import { RunEnvironment } from "src/runtime/enums";
 import { JSONUnixSocket } from "../common/utils/unixSocket";
 import { setTimeout } from "timers/promises";
 const startRunApiSchema = z.object({
-  type: z.literal("start"),
-  parameters: runApiParametersSchema.extend({
-    retrieveSession: z.boolean(),
-    context: z.object({
-      jobId: z.string().optional(),
-      jobRunId: z.string().optional(),
-      runId: z.string().optional(),
-      queueId: z.string().optional()
-    }).optional()
-  })
+    type: z.literal("start"),
+    parameters: runApiParametersSchema.extend({
+        retrieveSession: z.boolean(),
+        context: z
+            .object({
+            jobId: z.string().optional(),
+            jobRunId: z.string().optional(),
+            runId: z.string().optional(),
+            queueId: z.string().optional(),
+        })
+            .optional(),
+    }),
 });
 const nextRunApiSchema = z.object({
-  type: z.literal("next"),
-  parameters: z.object({
-    value: z.string()
-  })
+    type: z.literal("next"),
+    parameters: z.object({ value: z.string() }),
 });
 const abortRunApiSchema = z.object({
-  type: z.literal("abort"),
-  parameters: z.object({}).optional()
+    type: z.literal("abort"),
+    parameters: z.object({}).optional(),
 });
-const inputSchema = z.union([startRunApiSchema, nextRunApiSchema, abortRunApiSchema]);
+const inputSchema = z.union([
+    startRunApiSchema,
+    nextRunApiSchema,
+    abortRunApiSchema,
+]);
 dotenv.config({
-  path: `.env`
+    path: `.env`,
 });
-program.description("run user automation and communicate using unix socket").argument("<socket-path>", "path to unix socket").action(async socketPath => {
-  let context;
-  const throttleTime = 1_000;
-  let timeoutTimestamp = Date.now();
-  const client = net.createConnection(socketPath, () => {
-    console.log("connected to server!");
-  });
-  let generator = null;
-  const abortController = new AbortController();
-  client.on("end", () => {
-    console.log("Disconnected from socket");
-  });
-  client.on("error", err => {
-    var _generator;
-    console.error("Child connection error:", err);
-    void ((_generator = generator) === null || _generator === void 0 ? void 0 : _generator.throw(err).catch(() => undefined));
-  });
-  process.on("SIGINT", () => {
-    var _generator2;
-    console.log("Received SIGINT");
-    void ((_generator2 = generator) === null || _generator2 === void 0 ? void 0 : _generator2.throw(new Error("Interrupted")).catch(() => undefined));
-    client.end();
-    process.exit(1);
-  });
-  const jsonUnixSocket = new JSONUnixSocket(client);
-  async function runGeneratorAndSendResult(next) {
-    if (!generator) return;
-    const result = await runWithContext(context, () => generator.next(next));
-    if (result.done) {
-      const resultToSend = result.value.isOk() ? result.value.value : result.value.error.json;
-      const success = result.value.isOk();
-      jsonUnixSocket.sendJSON({
-        type: "done",
-        result: resultToSend,
-        success
-      });
-      return true;
-    } else {
-      jsonUnixSocket.sendJSON({
-        type: "yield",
-        result: result.value
-      });
-      return false;
-    }
-  }
-  for await (const data of jsonUnixSocket.receiveJSON()) {
-    const inputParseResult = inputSchema.safeParse(data);
-    if (!inputParseResult.success) {
-      console.error(inputParseResult.error.errors);
-      jsonUnixSocket.sendJSON({
-        type: "done",
-        result: {
-          error: "InvalidJSON",
-          message: "Invalid input",
-          details: {
-            errors: inputParseResult.error.errors
-          }
-        },
-        success: false
-      });
-      break;
-    }
-    const input = inputParseResult.data;
-    if (input.type === "abort") {
-      abortController.abort();
-      await setTimeout(10);
-      jsonUnixSocket.sendJSON({
-        type: "done",
-        result: null
-      });
-      break;
-    }
-    if (input.type === "start") {
-      const gen = runApiGenerator({
-        ...input.parameters,
-        abortSignal: abortController.signal
-      });
-      generator = gen;
-      context = {
-        extendedPayloads: [],
-        runEnvironment: input.parameters.runOptions.environment === "deployed" ? RunEnvironment.DEPLOYED : RunEnvironment.IDE,
-        timeoutInfo: {
-          extendTimeoutCallback: async () => {
-            if (Date.now() - timeoutTimestamp < throttleTime) return;
-            timeoutTimestamp = Date.now();
+program
+    .description("run user automation and communicate using unix socket")
+    .argument("<socket-path>", "path to unix socket")
+    .action(async (socketPath) => {
+    let context;
+    const throttleTime = 1_000;
+    let timeoutTimestamp = Date.now();
+    const client = net.createConnection(socketPath, () => {
+        console.log("connected to server!");
+    });
+    let generator = null;
+    const abortController = new AbortController();
+    client.on("end", () => {
+        console.log("Disconnected from socket");
+    });
+    client.on("error", (err) => {
+        console.error("Child connection error:", err);
+        void generator?.throw(err).catch(() => undefined);
+    });
+    process.on("SIGINT", () => {
+        console.log("Received SIGINT");
+        void generator?.throw(new Error("Interrupted")).catch(() => undefined);
+        client.end();
+        process.exit(1);
+    });
+    const jsonUnixSocket = new JSONUnixSocket(client);
+    async function runGeneratorAndSendResult(next) {
+        if (!generator)
+            return;
+        const result = await runWithContext(context, () => generator.next(next));
+        if (result.done) {
+            const resultToSend = result.value.isOk()
+                ? result.value.value
+                : result.value.error.json;
+            const success = result.value.isOk();
             jsonUnixSocket.sendJSON({
-              type: "extend"
+                type: "done",
+                result: resultToSend,
+                success,
             });
-          }
-        },
-        ...(input.parameters.context ?? {}),
-        proxy: getProxyUrlFromRunOptions(input.parameters.runOptions)
-      };
-      if (await runGeneratorAndSendResult()) {
-        break;
-      }
-      continue;
+            return true;
+        }
+        else {
+            jsonUnixSocket.sendJSON({ type: "yield", result: result.value });
+            return false;
+        }
     }
-    if (input.type === "next") {
-      if (!generator) {
-        throw new Error("generator not started");
-      }
-      if (await runGeneratorAndSendResult(input.parameters.value)) {
-        break;
-      }
-      continue;
+    for await (const data of jsonUnixSocket.receiveJSON()) {
+        const inputParseResult = inputSchema.safeParse(data);
+        if (!inputParseResult.success) {
+            console.error(inputParseResult.error.errors);
+            jsonUnixSocket.sendJSON({
+                type: "done",
+                result: {
+                    error: "InvalidJSON",
+                    message: "Invalid input",
+                    details: {
+                        errors: inputParseResult.error.errors,
+                    },
+                },
+                success: false,
+            });
+            break;
+        }
+        const input = inputParseResult.data;
+        if (input.type === "abort") {
+            abortController.abort();
+            await setTimeout(10);
+            jsonUnixSocket.sendJSON({ type: "done", result: null });
+            break;
+        }
+        if (input.type === "start") {
+            const gen = runApiGenerator({
+                ...input.parameters,
+                abortSignal: abortController.signal,
+            });
+            generator = gen;
+            context = {
+                extendedPayloads: [],
+                runEnvironment: input.parameters.runOptions.environment === "deployed"
+                    ? RunEnvironment.DEPLOYED
+                    : RunEnvironment.IDE,
+                timeoutInfo: {
+                    extendTimeoutCallback: async () => {
+                        if (Date.now() - timeoutTimestamp < throttleTime)
+                            return;
+                        timeoutTimestamp = Date.now();
+                        jsonUnixSocket.sendJSON({ type: "extend" });
+                    },
+                },
+                ...(input.parameters.context ?? {}),
+                proxy: getProxyUrlFromRunOptions(input.parameters.runOptions),
+            };
+            if (await runGeneratorAndSendResult()) {
+                break;
+            }
+            continue;
+        }
+        if (input.type === "next") {
+            if (!generator) {
+                throw new Error("generator not started");
+            }
+            if (await runGeneratorAndSendResult(input.parameters.value)) {
+                break;
+            }
+            continue;
+        }
     }
-  }
-  process.exit(0);
+    process.exit(0);
 });
 program.parse(process.argv);
 function getProxyUrlFromRunOptions(runOptions) {
-  if ((runOptions === null || runOptions === void 0 ? void 0 : runOptions.environment) !== "deployed") return undefined;
-  const proxy = runOptions.proxy;
-  if (!proxy) return undefined;
-  const url = new URL(proxy.server);
-  url.username = proxy.username;
-  url.password = proxy.password;
-  return url.toString();
-}
+    if (runOptions?.environment !== "deployed")
+        return undefined;
+    const proxy = runOptions.proxy;
+    if (!proxy)
+        return undefined;
+    const url = new URL(proxy.server);
+    url.username = proxy.username;
+    url.password = proxy.password;
+    return url.toString();
+}

package/dist/commands/interface/run.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import dotenv from "dotenv";
+import { runWithContext } from "../../common/asyncLocalStorage";
+import * as net from "net";
+import z from "zod";
+import { runApiGenerator, runApiParametersSchema } from "../../common/runApi";
+import { RunEnvironment } from "src/runtime/enums";
+import { JSONUnixSocket } from "../common/utils/unixSocket";
+import { setTimeout } from "timers/promises";
+const startRunApiSchema = z.object({
+  type: z.literal("start"),
+  parameters: runApiParametersSchema.extend({
+    retrieveSession: z.boolean(),
+    context: z.object({
+      jobId: z.string().optional(),
+      jobRunId: z.string().optional(),
+      runId: z.string().optional(),
+      queueId: z.string().optional()
+    }).optional()
+  })
+});
+const nextRunApiSchema = z.object({
+  type: z.literal("next"),
+  parameters: z.object({
+    value: z.string()
+  })
+});
+const abortRunApiSchema = z.object({
+  type: z.literal("abort"),
+  parameters: z.object({}).optional()
+});
+const inputSchema = z.union([startRunApiSchema, nextRunApiSchema, abortRunApiSchema]);
+dotenv.config({
+  path: `.env`
+});
+program.description("run user automation and communicate using unix socket").argument("<socket-path>", "path to unix socket").action(async socketPath => {
+  let context;
+  const throttleTime = 1_000;
+  let timeoutTimestamp = Date.now();
+  const client = net.createConnection(socketPath, () => {
+    console.log("connected to server!");
+  });
+  let generator = null;
+  const abortController = new AbortController();
+  client.on("end", () => {
+    console.log("Disconnected from socket");
+  });
+  client.on("error", err => {
+    var _generator;
+    console.error("Child connection error:", err);
+    void ((_generator = generator) === null || _generator === void 0 ? void 0 : _generator.throw(err).catch(() => undefined));
+  });
+  process.on("SIGINT", () => {
+    var _generator2;
+    console.log("Received SIGINT");
+    void ((_generator2 = generator) === null || _generator2 === void 0 ? void 0 : _generator2.throw(new Error("Interrupted")).catch(() => undefined));
+    client.end();
+    process.exit(1);
+  });
+  const jsonUnixSocket = new JSONUnixSocket(client);
+  async function runGeneratorAndSendResult(next) {
+    if (!generator) return;
+    const result = await runWithContext(context, () => generator.next(next));
+    if (result.done) {
+      const resultToSend = result.value.isOk() ? result.value.value : result.value.error.json;
+      const success = result.value.isOk();
+      jsonUnixSocket.sendJSON({
+        type: "done",
+        result: resultToSend,
+        success
+      });
+      return true;
+    } else {
+      jsonUnixSocket.sendJSON({
+        type: "yield",
+        result: result.value
+      });
+      return false;
+    }
+  }
+  for await (const data of jsonUnixSocket.receiveJSON()) {
+    const inputParseResult = inputSchema.safeParse(data);
+    if (!inputParseResult.success) {
+      console.error(inputParseResult.error.errors);
+      jsonUnixSocket.sendJSON({
+        type: "done",
+        result: {
+          error: "InvalidJSON",
+          message: "Invalid input",
+          details: {
+            errors: inputParseResult.error.errors
+          }
+        },
+        success: false
+      });
+      break;
+    }
+    const input = inputParseResult.data;
+    if (input.type === "abort") {
+      abortController.abort();
+      await setTimeout(10);
+      jsonUnixSocket.sendJSON({
+        type: "done",
+        result: null
+      });
+      break;
+    }
+    if (input.type === "start") {
+      const gen = runApiGenerator({
+        ...input.parameters,
+        abortSignal: abortController.signal
+      });
+      generator = gen;
+      context = {
+        extendedPayloads: [],
+        runEnvironment: input.parameters.runOptions.environment === "deployed" ? RunEnvironment.DEPLOYED : RunEnvironment.IDE,
+        timeoutInfo: {
+          extendTimeoutCallback: async () => {
+            if (Date.now() - timeoutTimestamp < throttleTime) return;
+            timeoutTimestamp = Date.now();
+            jsonUnixSocket.sendJSON({
+              type: "extend"
+            });
+          }
+        },
+        ...(input.parameters.context ?? {}),
+        proxy: getProxyUrlFromRunOptions(input.parameters.runOptions)
+      };
+      if (await runGeneratorAndSendResult()) {
+        break;
+      }
+      continue;
+    }
+    if (input.type === "next") {
+      if (!generator) {
+        throw new Error("generator not started");
+      }
+      if (await runGeneratorAndSendResult(input.parameters.value)) {
+        break;
+      }
+      continue;
+    }
+  }
+  process.exit(0);
+});
+program.parse(process.argv);
+function getProxyUrlFromRunOptions(runOptions) {
+  if ((runOptions === null || runOptions === void 0 ? void 0 : runOptions.environment) !== "deployed") return undefined;
+  const proxy = runOptions.proxy;
+  if (!proxy) return undefined;
+  const url = new URL(proxy.server);
+  url.username = proxy.username;
+  url.password = proxy.password;
+  return url.toString();
+}