@intuned/runtime-dev 0.0.1-testing.0 → 0.0.1

package/src/commands/common/getFirstLineNumber.ts

@@ -0,0 +1,146 @@
+import {
+  ts,
+  Project,
+  CompilerOptions,
+  ModuleKind,
+  ScriptTarget,
+  FunctionDeclaration,
+  SourceFile,
+  Node,
+} from "ts-morph";
+import { SourceMapConsumer } from "source-map";
+
+function compileTypeScript(apiFilePath: string) {
+  const compilerOptions: 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: SourceFile) {
+  let functionBody: ReturnType<FunctionDeclaration["getBody"]>;
+
+  // 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 as FunctionDeclaration
+      ).getBody();
+    } 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
+              ) as FunctionDeclaration);
+          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() as ReturnType<
+            FunctionDeclaration["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: string) {
+  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: string,
+  jsCode: string,
+  line: number,
+  column: number
+) {
+  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: string) {
+  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
+    ),
+  };
+}

package/src/commands/common/sendMessageToClient.ts

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

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

@@ -0,0 +1,25 @@
+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: string[]) {
+  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" as const) : ("File" as const),
+      fullPath: path.join(projectPath, file.name),
+      name: file.name,
+    }));
+  } catch (err) {
+    console.error("Error reading the directory:", err);
+    throw err;
+  }
+}

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

@@ -0,0 +1,23 @@
+import { getFullPathInProject } from "./fileUtils";
+import {
+  IntunedSettings,
+  settingsSchema,
+} from "../../../common/settingsSchema";
+
+export async function getSettings(): Promise<IntunedSettings> {
+  const settingsFilePath = getFullPathInProject("Intuned.json");
+  console.log("loading settings");
+
+  const settings = await import(settingsFilePath);
+  if (settings.default) {
+    const parsed = settingsSchema.safeParse(settings.default);
+    if (parsed.success) {
+      return parsed.data;
+    } else {
+      // ToDo: why does the type not work here?
+      throw new Error((parsed as any).error.message);
+    }
+  }
+
+  return { authSessions: { enabled: false } };
+}

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

@@ -0,0 +1,46 @@
+import * as fs from "fs-extra";
+import * as path from "path";
+
+import { getFullPathInProject, listProjectFilesAndFolders } from "./fileUtils";
+
+export const moveWebTemplateFiles = async () => {
+  await fs.remove("./intuned");
+  await fs.ensureDir("./intuned");
+
+  const currentFileLocation = path.resolve(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "..",
+    "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}`);
+  }
+};

package/src/commands/testing/saveVisibleHtml.ts

@@ -0,0 +1,29 @@
+import * as fs from "fs-extra";
+import dotenv from "dotenv";
+// import { getPageVisiblePageHtml } from "../../common/playwrightPageHelpers";
+import { getPlaywrightConstructsForMode } from "../../common/getPlaywrightConstructs";
+
+dotenv.config({
+  path: `.env`,
+});
+
+async function main() {
+  const { page } = await getPlaywrightConstructsForMode(
+    "playwright",
+    undefined
+  );
+
+  await page.goto(
+    "https://www.marriott.com/search/findHotels.mi?roomTypeCode=&recordsPerPage=20&autoSuggestItemType=&destinationAddress.types=locality,political&destinationAddress.latitude=47.6061389&propertyCode=&destinationAddress.stateProvinceShort=&isInternalSearch=true&destinationAddress.cityPopulation=&vsInitialRequest=false&searchType=InCity&destinationAddress.locality=&showAddressPin=&miniStoreFormSubmit=&destinationAddress.stateProvinceDisplayName=&destinationAddress.destinationPageDestinationAddress=&countryName=&destinationAddress.stateProvince=WA&searchRadius=50.0&singleSearchAutoSuggest=Unmatched&missingcheckInDateMsg=Please+enter+a+check-in+date.&destinationAddress.placeId=ChIJVTPokywQkFQRmtVEaUZlJRA&is-hotelsnearme-clicked=false&destinationAddress.addressline1=&airportName=&for-hotels-nearme=Near&missingcheckOutDateMsg=Please+enter+a+check-out+date.&suggestionsPropertyCode=&pageType=advanced&destinationAddress.country=US&destinationAddress.name=&poiCity=&destinationAddress.countryShort=&marriottBrands=&poiName=&destinationAddress.address=Seattle,+WA,+USA&search-countryRegion=&collapseAccordian=is-hidden&singleSearch=true&destinationAddress.cityPopulationDensity=&destinationAddress.secondaryText=WA,+USA&destinationAddress.postalCode=&destinationAddress.city=Seattle&destinationAddress.mainText=Seattle&airportCode=&isTransient=true&destinationAddress.longitude=-122.3328481&initialRequest=false&destinationAddress.website=https://maps.google.com/?q=Seattle,+WA,+USA&ftid=0x5490102c93e83355:0x102565466944d59a&search-locality=&dimensions=0&roomTypeCode=&propertyCode=&flexibleDateSearchRateDisplay=false&propertyName=&isSearch=true&marriottRewardsNumber=&isRateCalendar=false&incentiveType_Number=&incentiveType=&flexibleDateLowestRateMonth=&flexibleDateLowestRateDate=&marrOfferId=&isMultiRateSearch=&multiRateMaxCount=&multiRateCorpCodes=&useMultiRateRewardsPoints=&multiRateClusterCodes=&multiRateCorpCodesEntered=&lowestRegularRate=&js-location-nearme-values=&destinationAddress.destination=Seattle,+WA,+USA&fromToDate=10/07/2023&fromToDate_submit=10/08/2023&fromDate=10/07/2023&toDate=10/08/2023&toDateDefaultFormat=10/08/2023&fromDateDefaultFormat=10/07/2023&flexibleDateSearch=false&isHideFlexibleDateCalendar=false&t-start=2023-10-07&t-end=2023-10-08&lengthOfStay=1&roomCountBox=1+Room&roomCount=1&guestCountBox=1+Adult+Per+Room&numAdultsPerRoom=1&childrenCountBox=0+Children+Per+Room&childrenCount=0&childrenAges=&clusterCode=none&corporateCode=&useRewardsPoints=true&view=list#/0/",
+    { waitUntil: "load" }
+  );
+  await page.waitForTimeout(10000);
+
+  const html = ""; // await getPageVisiblePageHtml(page);
+
+  await fs.writeFile("./htmlFiles/marriott.html", html);
+
+  process.exit();
+}
+
+void main();

package/src/commands/ts-check.ts

@@ -0,0 +1,88 @@
+#!/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";
+
+program
+  .description("Check TypeScript types in the project")
+  .allowUnknownOption()
+  .action(async () => {
+    await moveWebTemplateFiles();
+
+    const templateTsConfig = path.resolve(
+      __dirname,
+      "..",
+      "..",
+      "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);

package/src/common/Logger/Logger/index.ts

@@ -0,0 +1,64 @@
+import { formatWithOptions } from "node:util";
+import { LogEntry, LogLevel, LogMetadata } from "./types";
+import chalk from "chalk";
+
+const format = formatWithOptions.bind(undefined, { colors: true });
+
+const LOG_LEVEL_COLORS: Record<LogLevel, chalk.Chalk> = {
+  TRACE: chalk.gray,
+  DEBUG: chalk.blue,
+  INFO: chalk.green,
+  WARN: chalk.yellow,
+  ERROR: chalk.red,
+};
+
+class Logger {
+  logFunction(entry: LogEntry): void {
+    const { level, timestamp, message, meta } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+
+    if (meta === undefined) {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`
+      );
+    } else {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(
+          level
+        )}] ${message} ${format(meta)}\n`
+      );
+    }
+  }
+
+  private log(level: LogLevel, message: string, meta?: LogMetadata): void {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now(),
+    });
+  }
+
+  trace(message: string, meta?: LogMetadata): void {
+    this.log("TRACE", message, meta);
+  }
+
+  debug(message: string, meta?: LogMetadata): void {
+    this.log("DEBUG", message, meta);
+  }
+
+  info(message: string, meta?: LogMetadata): void {
+    this.log("INFO", message, meta);
+  }
+
+  warn(message: string, meta?: LogMetadata): void {
+    this.log("WARN", message, meta);
+  }
+
+  error(message: string, meta?: LogMetadata): void {
+    this.log("ERROR", message, meta);
+  }
+}
+
+export const logger = new Logger();

package/{dist/common/Logger/types.d.ts → src/common/Logger/Logger/types.ts}

@@ -1,8 +1,9 @@
 export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
 export type LogMetadata = Record<string | symbol, any>;
+
 export interface LogEntry {
-    level: LogLevel;
-    message: string;
-    timestamp: number;
-    meta?: LogMetadata;
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+  meta?: LogMetadata;
 }

package/src/common/Logger/index.ts

@@ -0,0 +1,64 @@
+import { formatWithOptions } from "node:util";
+import { LogEntry, LogLevel, LogMetadata } from "./types";
+import chalk from "chalk";
+
+const format = formatWithOptions.bind(undefined, { colors: true });
+
+const LOG_LEVEL_COLORS: Record<LogLevel, chalk.Chalk> = {
+  TRACE: chalk.gray,
+  DEBUG: chalk.blue,
+  INFO: chalk.green,
+  WARN: chalk.yellow,
+  ERROR: chalk.red,
+};
+
+class Logger {
+  logFunction(entry: LogEntry): void {
+    const { level, timestamp, message, meta } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+
+    if (meta === undefined) {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`
+      );
+    } else {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(
+          level
+        )}] ${message} ${format(meta)}\n`
+      );
+    }
+  }
+
+  private log(level: LogLevel, message: string, meta?: LogMetadata): void {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now(),
+    });
+  }
+
+  trace(message: string, meta?: LogMetadata): void {
+    this.log("TRACE", message, meta);
+  }
+
+  debug(message: string, meta?: LogMetadata): void {
+    this.log("DEBUG", message, meta);
+  }
+
+  info(message: string, meta?: LogMetadata): void {
+    this.log("INFO", message, meta);
+  }
+
+  warn(message: string, meta?: LogMetadata): void {
+    this.log("WARN", message, meta);
+  }
+
+  error(message: string, meta?: LogMetadata): void {
+    this.log("ERROR", message, meta);
+  }
+}
+
+export const logger = new Logger();

package/{dist/common/Logger/Logger/types.d.ts → src/common/Logger/types.ts}

@@ -1,8 +1,9 @@
 export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
 export type LogMetadata = Record<string | symbol, any>;
+
 export interface LogEntry {
-    level: LogLevel;
-    message: string;
-    timestamp: number;
-    meta?: LogMetadata;
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+  meta?: LogMetadata;
 }

package/src/common/asyncLocalStorage/index.ts

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { Payload, RunInfo } from "../../runtime/export";
+
+export const asyncLocalStorage = new AsyncLocalStorage<InternalRunInfo>();
+
+export function runWithContext<R, TArgs extends any[]>(
+  contextData: InternalRunInfo,
+  callback: (...args: TArgs) => R,
+  ...args: TArgs
+): R {
+  return asyncLocalStorage.run(contextData, callback, ...args);
+}
+
+interface TimeoutInfo {
+  extendTimeoutCallback?: () => Promise<void>;
+  timeoutDuration?: number;
+  timeoutTimestamp?: number;
+}
+
+interface InternalRunInfo extends RunInfo {
+  extendedPayloads: Payload[];
+  timeoutInfo?: TimeoutInfo;
+}
+
+export function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+
+  return contextData as InternalRunInfo | undefined;
+}

package/src/common/cleanEnvironmentVariables.ts

@@ -0,0 +1,13 @@
+export function cleanEnvironmentVariables() {
+  Object.keys(process.env)
+    .filter((i) => {
+      if (i.toLocaleLowerCase().startsWith("npm")) {
+        return true;
+      }
+
+      if (i.toLocaleLowerCase().startsWith("fly") && i !== "FLY_ALLOC_ID") {
+        return true;
+      }
+    })
+    .forEach((i) => delete process.env[i]);
+}

package/src/common/constants.ts

@@ -0,0 +1 @@
+export const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";

package/src/common/contextStorageStateHelpers.ts

@@ -0,0 +1,71 @@
+import { BrowserContext } from "@intuned/playwright";
+import * as playwright from "@intuned/playwright-core";
+
+function sessionStorageToArray(
+  storage: Record<string, string>
+): { name: string; value: string }[] {
+  const result: { name: string; value: string }[] = [];
+
+  for (const key in storage) {
+    result.push({ name: key, value: storage[key] });
+  }
+
+  return result;
+}
+
+interface OriginSessionStorage {
+  origin: string;
+  sessionStorage: Array<{
+    name: string;
+    value: string;
+  }>;
+}
+
+export type IntunedStorageState = Exclude<
+  playwright.BrowserContextOptions["storageState"],
+  string
+> & {
+  sessionStorage?: OriginSessionStorage[];
+};
+
+export async function getContextStorageState(
+  context: BrowserContext
+): Promise<IntunedStorageState> {
+  const cookiesAndLocalStorage = await context.storageState();
+  const pages = await context.pages();
+
+  const pagesSessions: OriginSessionStorage[] = [];
+  for (const page of pages) {
+    const [origin, session] = await page.evaluate(() => [
+      location.origin,
+      sessionStorage as Record<string, string>,
+    ]);
+
+    const transformed = sessionStorageToArray(session);
+
+    pagesSessions.push({ origin, sessionStorage: transformed });
+  }
+
+  return {
+    ...cookiesAndLocalStorage,
+    sessionStorage: pagesSessions,
+  };
+}
+
+export async function setContextStorageState(
+  context: BrowserContext,
+  storage: IntunedStorageState
+) {
+  await (context as any).intunedSetStorageState(storage);
+
+  const sessionStorage = storage.sessionStorage;
+
+  await context.addInitScript((storage) => {
+    for (const { origin, sessionStorage } of storage) {
+      if (window.location.origin === origin) {
+        for (const item of sessionStorage)
+          window.sessionStorage.setItem(item.name, item.value);
+      }
+    }
+  }, sessionStorage);
+}