@intuned/runtime-dev 1.3.17-ws.0 → 1.3.18-dev.2

package/dist/commands/intuned-cli/controller/provision.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = void 0;
+exports.runProvisionProject = runProvisionProject;
+exports.validateProjectName = exports.validateIntunedProject = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _zod = require("zod");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../constants");
+var _helpers = require("../helpers");
+var _terminal = require("../helpers/terminal");
+var _build = require("./build");
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _constants2 = require("../../../common/constants");
+var _ignore = _interopRequireDefault(require("ignore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const provisionProjectApiResponseSchema = _zod.z.string().transform((val, ctx) => {
+  try {
+    return JSON.parse(val);
+  } catch (e) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Response is not valid JSON"
+    });
+    return _zod.z.NEVER;
+  }
+}).pipe(_zod.z.object({
+  id: _zod.z.string().uuid(),
+  enableFirstRunExperience: _zod.z.boolean().optional(),
+  environmentVariablesKeys: _zod.z.array(_zod.z.string()).default([]).catch(() => [])
+}));
+async function runProvisionProject(projectName, auth, silent = false) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}`;
+  const headers = {
+    [_constants2.API_KEY_HEADER_NAME]: apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
+  codeTree["Intuned.json"] = {
+    file: {
+      contents: JSON.stringify(intunedSettingsFile.parse(await fs.readFile(intunedSettingsFile.path, "utf-8")))
+    }
+  };
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const upsertProjectPayload = {
+    codeTree,
+    platformType: "CLI",
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "PUT",
+    body: JSON.stringify(upsertProjectPayload)
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new _helpers.CLIError(`Invalid API key. The provided API key is not authorized to access this workspace.\n` + `Please verify your API key at: https://app.intuned.io/settings/api-keys`);
+    }
+    throw new _helpers.CLIError(`^r^+Project provisioning failed:^:\n` + `^RServer returned status ${response.status}^:\n` + `^RResponse: ${await response.text()}^:\n\n` + `^yCommon causes:^:\n` + `  • Invalid workspace ID or project name\n` + `  • Insufficient permissions\n` + `  • Network connectivity issues\n` + `  • Project structure validation errors\n`, {
+      autoColor: false
+    });
+  }
+  if (!silent) {
+    (0, _terminal.terminal)("^g^+Project provisioned successfully!^:\n");
+  }
+  const body = await response.text();
+  const parseResult = provisionProjectApiResponseSchema.safeParse(body);
+  if (!parseResult.success) {
+    (0, _terminal.terminal)(`^yWarning: Could not parse provision project response:^:\n`);
+    (0, _terminal.terminal)(body + "\n");
+    return;
+  }
+  const {
+    id: projectId,
+    enableFirstRunExperience,
+    environmentVariablesKeys
+  } = parseResult.data;
+  const dotEnvPath = path.join(projectPath, ".env");
+  if (!(await fs.exists(dotEnvPath))) {
+    await fs.writeFile(dotEnvPath, `${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}
+${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}
+${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`);
+    (0, _terminal.terminal)(`^g^+Created .env file with project credentials.^:\n`);
+    return {
+      projectId,
+      enableFirstRunExperience,
+      environmentVariablesKeys,
+      dotenvContent: {}
+    };
+  }
+  const envContent = await fs.readFile(dotEnvPath, "utf-8");
+  const dotenvContent = dotenv.parse(envContent);
+  let contentToAppend = "";
+  const projectCredentialsEnvVars = {
+    [_constants2.PROJECT_ID_ENV_VAR_KEY]: projectId,
+    [_constants2.WORKSPACE_ID_ENV_VAR_KEY]: workspaceId,
+    [_constants2.API_KEY_ENV_VAR_KEY]: apiKey
+  };
+  for (const key in projectCredentialsEnvVars) {
+    if (dotenvContent[key] === projectCredentialsEnvVars[key]) {
+      continue;
+    }
+    if (dotenvContent[key]) {
+      (0, _terminal.terminal)(`^yWarning: Existing ${key} in .env has invalid value. Appending correct value.^:\n`);
+    }
+    contentToAppend += `${key}=${projectCredentialsEnvVars[key]}\n`;
+  }
+  if (contentToAppend) {
+    await fs.appendFile(dotEnvPath, contentToAppend + "\n");
+    (0, _terminal.terminal)(`^g^+Updated .env file with project credentials.^:\n`);
+  }
+  const dotenvContentToReturn = {
+    ...dotenvContent
+  };
+  for (const key of [_constants2.PROJECT_ID_ENV_VAR_KEY, _constants2.WORKSPACE_ID_ENV_VAR_KEY, _constants2.API_KEY_ENV_VAR_KEY]) {
+    if (key in dotenvContentToReturn) {
+      delete dotenvContentToReturn[key];
+    }
+  }
+  return {
+    projectId,
+    enableFirstRunExperience,
+    environmentVariablesKeys,
+    dotenvContent: dotenvContentToReturn
+  };
+}
+const projectNameSchema = exports.projectNameSchema = _zod.z.string().min(1, "Name is required").max(200, "Must be 200 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
+  message: "Cannot be a UUID"
+});
+const validateProjectName = projectName => {
+  const validation = projectNameSchema.safeParse(projectName);
+  if (!validation.success) {
+    return {
+      isValid: false,
+      errorMessage: validation.error.errors[0].message
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateProjectName = validateProjectName;
+const validateIntunedProject = async () => {
+  const currentDirectoryToProvision = process.cwd();
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
+  const validationSteps = [{
+    name: "build",
+    check: async () => {
+      try {
+        const buildResult = await (0, _build.runBuild)();
+        if (!buildResult) {
+          return {
+            isValid: false,
+            errorMessage: "Build failed"
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Build failed"
+        };
+      }
+    }
+  }, {
+    name: intunedSettingsFile.name,
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToProvision, intunedSettingsFile.name);
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: `${intunedSettingsFile.name} file not found`
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToProvision, "api");
+        await fs.access(apiFolderPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "API folder not found"
+        };
+      }
+    }
+  }];
+  for (const step of validationSteps) {
+    const result = await step.check();
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateIntunedProject = validateIntunedProject;
+async function convertProjectToCodeTree(projectPath) {
+  const ig = (0, _ignore.default)();
+  const gitIgnorePath = await findGitIgnoreFile(projectPath);
+  if (gitIgnorePath) {
+    const gitIgnoreContent = await fs.readFile(gitIgnorePath, "utf-8");
+    ig.add(gitIgnoreContent);
+  }
+  ig.add(_projectExclusions.default);
+  async function traverse(dirPath) {
+    const tree = {};
+    const fileNames = [];
+    const entries = await fs.readdir(dirPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      if (ig.ignores(path.relative(projectPath, entryPath))) {
+        continue;
+      }
+      if (entry.isFile()) {
+        try {
+          const content = await fs.readFile(entryPath, "utf-8");
+          tree[entry.name] = {
+            file: {
+              contents: content
+            }
+          };
+          fileNames.push(path.relative(projectPath, entryPath));
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
+        }
+      } else if (entry.isDirectory()) {
+        const {
+          tree: subTree,
+          fileNames: subFileNames
+        } = await traverse(entryPath);
+        fileNames.push(...subFileNames);
+        if (Object.keys(subTree).length > 0) {
+          tree[entry.name] = {
+            directory: subTree
+          };
+        }
+      }
+    }
+    return {
+      tree,
+      fileNames
+    };
+  }
+  const {
+    tree,
+    fileNames
+  } = await traverse(projectPath);
+  const filesToProvisionText = "  " + fileNames.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be provisioned:^:\n");
+  (0, _terminal.terminal)(filesToProvisionText + "\n");
+  return tree;
+}
+async function findGitIgnoreFile(projectPath) {
+  let currentDirectory = projectPath;
+  while (true) {
+    const gitIgnorePath = path.join(currentDirectory, ".gitignore");
+    if (await fs.exists(gitIgnorePath)) {
+      return gitIgnorePath;
+    }
+    const parentDirectory = path.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      break;
+    }
+    currentDirectory = parentDirectory;
+  }
+  return null;
+}

package/dist/commands/intuned-cli/controller/scaffold.d.ts

@@ -0,0 +1 @@
+export declare function scaffoldAuthSessionFiles(): Promise<void>;

package/dist/commands/intuned-cli/controller/scaffold.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaffoldAuthSessionFiles = scaffoldAuthSessionFiles;
+var _zod = require("zod");
+var _helpers = require("../helpers");
+var _types = require("../types");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _constants = require("../../../common/constants");
+var _fsExtra = require("fs-extra");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const authSessionTemplateResponseSchema = _zod.z.object({
+  "auth-sessions": _types.fileSystemTreeSchema
+});
+async function scaffoldAuthSessionFiles() {
+  const [createResult, checkResult] = await Promise.all([(0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`), (0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`)]);
+  const createExists = createResult.isOk() || createResult.error.type !== "not_found";
+  const checkExists = checkResult.isOk() || checkResult.error.type !== "not_found";
+  if (createExists && checkExists) {
+    (0, _helpers.terminal)("^g^+AuthSession files already exist^:\n");
+    return;
+  }
+  (0, _helpers.terminal)("^g^+Scaffolding...^:\n");
+  const authSessionTemplateUrl = new URL("/api/v1/templates/authsession", (0, _helpers.getBaseUrl)());
+  authSessionTemplateUrl.searchParams.append("language", "typescript");
+  const response = await fetch(authSessionTemplateUrl.toString(), {
+    method: "GET"
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`Failed to fetch AuthSession template
+Got ${response.status} ${response.statusText}
+${text}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Failed to parse AuthSession template response as JSON
+${text}`);
+  }
+  const parseResult = authSessionTemplateResponseSchema.safeParse(json);
+  if (!parseResult.success) {
+    throw new Error(`AuthSession template response has invalid shape: ${JSON.stringify(parseResult.error.errors, null, 2)}`);
+  }
+  const authSessionsContent = parseResult.data["auth-sessions"];
+  const cwd = process.cwd();
+  const exists = {
+    create: createExists,
+    check: checkExists
+  };
+  await (0, _fsExtra.ensureDir)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME));
+  for (const api in exists) {
+    if (exists[api]) {
+      continue;
+    }
+    const [name, node] = Object.entries(authSessionsContent).find(entry => "file" in entry[1] && entry[0].replace(/\.[^/.]+$/, "") === api) ?? [undefined, undefined];
+    if (!name || !node) {
+      continue;
+    }
+    const {
+      file: {
+        contents
+      }
+    } = node;
+    if (typeof contents !== "string") {
+      continue;
+    }
+    await (0, _fsExtra.writeFile)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME, name), contents, {
+      encoding: "utf-8"
+    });
+    (0, _helpers.terminal)(`^g^+Written ^_${_path.default.join(_constants.AUTH_SESSIONS_FOLDER_NAME, name)}^:\n`);
+  }
+}

package/dist/commands/intuned-cli/helpers/__test__/browser.test.js

@@ -3,6 +3,7 @@
 var _vitest = require("vitest");
 var _browser = require("../browser");
 var _launchBrowser = require("../../../../common/launchBrowser");
+var _errors = require("../errors");
 function getTerminal() {
   return new Proxy(() => ({}), {
     get: () => getTerminal(),
@@ -10,6 +11,7 @@ function getTerminal() {
   });
 }
 _vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
   exists: _vitest.vi.fn().mockResolvedValue(true)
 }));
 _vitest.vi.mock("portfinder", () => ({
@@ -21,7 +23,8 @@ _vitest.vi.mock("../../../../common/launchBrowser", () => ({
       close: _vitest.vi.fn().mockResolvedValue(undefined)
     },
     page: {}
-  }))
+  })),
+  getIgnoreHttpErrorsFromConfig: _vitest.vi.fn().mockResolvedValue(false)
 }));
 _vitest.vi.mock("../../helpers/terminal", () => ({
   terminal: getTerminal()
@@ -38,8 +41,21 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
     terminal: getTerminal()
   };
 });
+_vitest.vi.mock("../../../../common/browserTabs", () => {
+  return {
+    getCDPTabs: _vitest.vi.fn().mockResolvedValue([{
+      id: "tab1",
+      title: "Tab 1",
+      url: "http://example.com/1"
+    }, {
+      id: "tab2",
+      title: "Tab 2",
+      url: "http://example.com/2"
+    }])
+  };
+});
 (0, _vitest.describe)("Browser CLI options", () => {
-  (0, _vitest.it)("returns cdp options if cdpUrl is set", async () => {
+  (0, _vitest.it)("returns cdp options with first tab if cdpUrl is set and no cdpTabId is not provided", async () => {
     const options = await (0, _browser.getCLIRunOptions)({
       keepBrowserOpen: true,
       headless: true,
@@ -47,9 +63,32 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
     });
     (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
       environment: "cdp",
-      cdpAddress: "cdp_url"
+      cdpAddress: "cdp_url",
+      cdpTargetId: "tab1"
+    }));
+  });
+  (0, _vitest.it)("returns cdp options with selected tab if cdpUrl and cdpTabId are provided", async () => {
+    const options = await (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url",
+      cdpTabId: "tab2"
+    });
+    (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+      environment: "cdp",
+      cdpAddress: "cdp_url",
+      cdpTargetId: "tab2"
     }));
   });
+  (0, _vitest.it)("fails in cdp options if cdp url is provided and invalid tab id is provided", async () => {
+    const optionsPromise = (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url",
+      cdpTabId: "tab3"
+    });
+    await (0, _vitest.expect)(optionsPromise).rejects.toThrowError(_errors.CLIError);
+  });
   (0, _vitest.it)("returns standalone options if keepBrowserOpen is not set", async () => {
     const options = await (0, _browser.getCLIRunOptions)({
       keepBrowserOpen: false,
@@ -61,7 +100,7 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
     }));
   });
   (0, _vitest.describe)("when keepBrowserOpen is set", () => {
-    beforeEach(async () => {
+    (0, _vitest.beforeEach)(async () => {
       _vitest.vi.clearAllMocks();
       await (0, _browser.closeCliBrowser)();
     });
@@ -74,7 +113,8 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
       (0, _vitest.expect)(_launchBrowser.launchChromium).toHaveBeenCalledWith({
         headless: false,
         cdpPort: 1234,
-        proxy: "proxy"
+        proxy: "proxy",
+        ignoreHttpErrors: false
       });
       (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
         environment: "cdp",

package/dist/commands/intuned-cli/helpers/__test__/tracing.test.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var _vitest = require("vitest");
-var _ = require("..");
+var _dist = require("../../../../../dist");
 function getTerminal() {
   return new Proxy(() => ({}), {
     get: () => getTerminal(),
@@ -9,6 +9,7 @@ function getTerminal() {
   });
 }
 _vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
   exists: _vitest.vi.fn().mockResolvedValue(true)
 }));
 _vitest.vi.mock("../../helpers/terminal", () => ({
@@ -24,14 +25,14 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
 (0, _vitest.describe)("Tracing wrapper", () => {
   (0, _vitest.it)("calls wrapped function with disabled tracing when id is undefined", async () => {
     const fn = _vitest.vi.fn();
-    await (0, _.withCLITrace)(fn, undefined);
+    await (0, _dist.withCLITrace)(fn, undefined);
     (0, _vitest.expect)(fn).toHaveBeenCalledWith({
       enabled: false
     });
   });
   (0, _vitest.it)("calls wrapped function with enabled tracing when id is defined", async () => {
     const fn = _vitest.vi.fn();
-    await (0, _.withCLITrace)(fn, "trace-id");
+    await (0, _dist.withCLITrace)(fn, "trace-id");
     (0, _vitest.expect)(fn).toHaveBeenCalledWith({
       enabled: true,
       filePath: _vitest.expect.stringContaining("trace-id")

package/dist/commands/intuned-cli/helpers/api.js

@@ -4,15 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assertApiFileExists = assertApiFileExists;
-var _path = _interopRequireDefault(require("path"));
-var _fsExtra = require("fs-extra");
 var _errors = require("./errors");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _tsNodeImport = require("../../common/tsNodeImport");
 async function assertApiFileExists(dirname, api) {
-  const file = `${dirname}/${api}.ts`;
-  const filePath = _path.default.join(process.cwd(), file);
-  if (!(await (0, _fsExtra.exists)(filePath))) {
-    throw new _errors.CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+is not implemented.^:`, {
+  const result = await (0, _tsNodeImport.tsNodeImport)(`${dirname}/${api}`);
+  if (result.isErr() && result.error.type === "not_found") {
+    throw new _errors.CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+does not exist. Make sure to use an existing API name.^:`, {
       autoColor: false
     });
   }

package/dist/commands/intuned-cli/helpers/auth.d.ts

@@ -1,15 +1,15 @@
 import type { AuthSessionMetadata } from "../types";
-import { RunApiStorageState as StorageState } from "../../../common/runApi";
+import { RunApiStorageState } from "@intuned/runtime-interface";
 export declare function isAuthEnabled(): Promise<boolean>;
 export declare function assertAuthEnabled(): Promise<void>;
 export declare function assertAuthConsistent(authSession: string | undefined): Promise<void>;
 export declare function loadAuthSessionInstance(authSessionId: string): Promise<{
     storageState: {
         cookies: {
-            path: string;
             value: string;
-            domain: string;
+            path: string;
             name: string;
+            domain: string;
             expires: number;
             httpOnly: boolean;
             secure: boolean;
@@ -33,7 +33,7 @@ export declare function loadAuthSessionInstance(authSessionId: string): Promise<
     metadata: AuthSessionMetadata;
 }>;
 export declare function storeAuthSessionInstance({ state, id, input, proxy, metadata, }: {
-    state: StorageState;
+    state: RunApiStorageState;
     id: string;
     input?: Record<string, any>;
     proxy?: string;