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

package/dist/commands/auth-sessions/run-create.ts

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-import { Argument, program } from "commander";
-import * as fs from "fs-extra";
-import { prompt } from "promptly";
-import { getFullPathInProject } from "../common/utils/fileUtils";
-import { getSettings } from "../common/utils/settings";
-import dotenv from "dotenv";
-import { AUTH_SESSIONS_FOLDER_NAME } from "../../common/constants";
-import { runApiGenerator } from "../../common/runApi";
-import { runWithContext } from "../../common/asyncLocalStorage";
-import { nanoid } from "nanoid";
-import { RunEnvironment } from "../../runtime/enums";
-dotenv.config({
-  path: `.env`
-});
-program.description("run auth session create").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--pathToSave <pathToSave>", "path to save the auth session, if not provided, will discard the auth session").allowUnknownOption().addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
-  cdpAddress,
-  pathToSave,
-  input,
-  json
-}) => {
-  let inputData = null;
-  if (input) {
-    inputData = await fs.readJSON(input);
-  } else if (json) {
-    inputData = JSON.parse(json);
-  } else {
-    inputData = {};
-  }
-  const setting = await getSettings();
-  if (!setting.authSessions.enabled) {
-    throw new Error("auth sessions feature is not enabled");
-  }
-  const createFilePath = getFullPathInProject(AUTH_SESSIONS_FOLDER_NAME, "create.ts");
-  if (!fs.exists(createFilePath)) {
-    throw new Error("auth session create file not found");
-  }
-  async function runCreate() {
-    const generator = runApiGenerator({
-      automationFunction: {
-        name: "auth-sessions/create",
-        params: inputData ?? {}
-      },
-      runOptions: {
-        environment: "ide",
-        mode,
-        cdpAddress
-      },
-      retrieveSession: true
-    });
-    let nextGeneratorParam = undefined;
-    while (true) {
-      const {
-        value,
-        done
-      } = await generator.next(...(nextGeneratorParam ? [nextGeneratorParam] : []));
-      if (done) {
-        if (value.isErr()) {
-          console.log(value.error);
-          throw new Error(value.error);
-        }
-        const fullState = value.value.session;
-        if (pathToSave) {
-          const fullPath = getFullPathInProject(pathToSave);
-          fs.ensureFileSync(fullPath);
-          await fs.writeJSON(fullPath, fullState);
-        }
-        break;
-      }
-      if (value.action === "request_more_info" && value.requestType == "multiple_choice") {
-        nextGeneratorParam = await prompt(value.messageToUser + `, choices: ${value.choices}`, {
-          validator: input => {
-            if (!value.choices.includes(input)) {
-              throw new Error("Please type on of the allowed choices");
-            }
-            return input;
-          }
-        });
-      } else if (value.action === "request_more_info" && value.requestType == "otp") {
-        nextGeneratorParam = await prompt(value.messageToUser, {});
-      }
-    }
-  }
-  await runWithContext({
-    runEnvironment: RunEnvironment.IDE,
-    extendedPayloads: [],
-    runId: nanoid()
-  }, runCreate);
-  process.exit(0);
-});
-program.parse(process.argv);

package/dist/commands/browser/save-state.ts

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import { saveSessionFromOpenedBrowser } from "../common/browserUtils";
-import dotenv from "dotenv";
-dotenv.config({
-  path: `.env`
-});
-program.description("save browser state to file storage.json").option("-p, --path [file]", "path for file", "./localSessions/default.json").allowUnknownOption().action(async ({
-  path
-}) => {
-  await saveSessionFromOpenedBrowser(path);
-  process.exit(0);
-});
-program.parse(process.argv);

package/dist/commands/browser/start-browser.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import { startOrRestartBrowser } from "../common/browserUtils";
-import dotenv from "dotenv";
-dotenv.config({
-  path: `.env`
-});
-program.description("start browser testing purposes").allowUnknownOption().action(async () => {
-  await startOrRestartBrowser();
-});
-program.parse(process.argv);

package/dist/commands/build.ts

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-import { program, Argument } from "commander";
-import { rollup } from "rollup";
-import typescript from "@rollup/plugin-typescript";
-import commonjs from "@rollup/plugin-commonjs";
-import { nodeResolve } from "@rollup/plugin-node-resolve";
-import dynamicImportVars from "@rollup/plugin-dynamic-import-vars";
-import json from "@rollup/plugin-json";
-import * as fs from "fs-extra";
-import * as path from "path";
-import { moveWebTemplateFiles } from "./common/utils/webTemplate.js";
-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;
-}
-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);
-});
-async function build(outfile, mode) {
-  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"
-      }), commonjs({
-        include: ["node_modules/**", "intuned/WebTemplate/**", "dist", "../typescript-sdk/**", "../typescript-runtime/**"],
-        extensions: [".js"],
-        ignoreGlobal: false,
-        sourceMap: false,
-        dynamicRequireTargets: ["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);
-    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);
-  }
-}
-program.parse(process.argv);

package/dist/commands/common/browserUtils.ts

@@ -1,45 +0,0 @@
-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"];
-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;
-}
-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}`);
-  });
-}
-export async function saveSessionFromOpenedBrowser(path) {
-  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);
-}
-export async function saveSession(path, context) {
-  const fullState = await getContextStorageState(context);
-  const fullPath = getFullPathInProject(path);
-  fs.ensureFileSync(fullPath);
-  await fs.writeJSON(fullPath, fullState);
-}

package/dist/commands/common/getDefaultExportFromFile.ts

@@ -1,11 +0,0 @@
-export async function getDefaultExportFromFile(apiFilePath) {
-  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.ts

@@ -1,96 +0,0 @@
-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
-  };
-}
-export function findFirstExecutableLine(sourceFile) {
-  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;
-          }
-        }
-        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);
-}
-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);
-}
-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;
-}
-export default async function getFirstLineNumber(apiFilePath) {
-  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/sendMessageToClient.ts

@@ -1,3 +0,0 @@
-export const sendBreakPointOnToClient = (sourceFileName, lineNumber) => {
-  console.log(`breakpoint on ${sourceFileName}:${lineNumber}`);
-};

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

@@ -1,23 +0,0 @@
-import * as path from "path";
-import * as fs from "fs-extra";
-import dotenv from "dotenv";
-dotenv.config();
-export function getFullPathInProject(...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;
-  }
-}

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

@@ -1,22 +0,0 @@
-import { getFullPathInProject } from "./fileUtils.js";
-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 {
-      throw new Error(parsed.error.message);
-    }
-  }
-  return {
-    authSessions: {
-      enabled: false
-    }
-  };
-}

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

@@ -1,38 +0,0 @@
-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.ts

@@ -1,22 +0,0 @@
-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.ts

@@ -1,156 +0,0 @@
-#!/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();
-}

package/dist/commands/ts-check.ts

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import * as ts from "typescript";
-import { program } from "commander";
-import * as fs from "fs-extra";
-import * as path from "path";
-import { moveWebTemplateFiles } from "./common/utils/webTemplate.js";
-program.description("Check TypeScript types in the project").allowUnknownOption().action(async () => {
-  await moveWebTemplateFiles();
-  const templateTsConfig = path.resolve(path.dirname(import.meta.url), "..", "..", "template.tsconfig.json");
-  await fs.copy(templateTsConfig, "./intuned/WebTemplate/tsconfig.json");
-  checkTypes();
-});
-function checkTypes() {
-  const configPath = ts.findConfigFile("./intuned/WebTemplate", ts.sys.fileExists, "tsconfig.json");
-  if (!configPath) {
-    console.error("Could not find a valid 'tsconfig.json'.");
-    process.exit(1);
-  }
-  const readConfigResult = ts.readConfigFile(configPath, ts.sys.readFile);
-  const config = readConfigResult.config;
-  const parseConfigHost = {
-    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
-    readDirectory: ts.sys.readDirectory,
-    fileExists: ts.sys.fileExists,
-    readFile: ts.sys.readFile
-  };
-  const parsed = ts.parseJsonConfigFileContent(config, parseConfigHost, "./intuned");
-  const program = ts.createProgram(parsed.fileNames, parsed.options);
-  const emitResult = program.emit();
-  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-  allDiagnostics.forEach(diagnostic => {
-    if (diagnostic.file) {
-      const {
-        line,
-        character
-      } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-      console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
-    } else {
-      console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
-    }
-  });
-  if (allDiagnostics.length === 0) {
-    console.log("✨ TypeScript type checking passed without errors.");
-  } else {
-    console.error("Errors found during TypeScript type checking.");
-    process.exit(1);
-  }
-}
-program.parse(process.argv);