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

package/dist/commands/common/browserUtils.js

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

package/dist/commands/common/browserUtils.ts

@@ -0,0 +1,45 @@
+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.js

@@ -1,11 +1,12 @@
 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;
-}
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require("ts-node").register({
+        transpileOnly: true,
+        compilerOptions: {
+            lib: ["dom", "es2020"],
+        },
+    });
+    const imported = await import(apiFilePath);
+    const defaultExport = imported.default;
+    return defaultExport;
+}

package/dist/commands/common/getDefaultExportFromFile.ts

@@ -0,0 +1,11 @@
+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.js

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

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

package/dist/commands/common/getFirstLineNumber.ts

@@ -0,0 +1,96 @@
+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.js

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

package/dist/commands/common/sendMessageToClient.ts

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

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

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

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

@@ -0,0 +1,23 @@
+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.js

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

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

@@ -0,0 +1,22 @@
+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
+    }
+  };
+}