@intuned/runtime 1.3.18-interface.7 → 1.3.18

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

@@ -0,0 +1,16 @@
+import { RunAutomationError } from "@intuned/runtime-interface";
+export declare class CLIError extends Error {
+    autoColor: boolean;
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare class AbortedCLIError extends CLIError {
+    constructor();
+}
+export declare class CLIAssertionError extends CLIError {
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare function logAutomationError(error: RunAutomationError): void;

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLIError = exports.CLIAssertionError = exports.AbortedCLIError = void 0;
+exports.logAutomationError = logAutomationError;
+var _runtimeInterface = require("../../../vendor/runtime-interface");
+var _terminal = require("./terminal");
+class CLIError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "CLIError";
+    this.autoColor = options?.autoColor ?? true;
+  }
+}
+exports.CLIError = CLIError;
+class AbortedCLIError extends CLIError {
+  constructor() {
+    super("Aborted");
+    this.name = "AbortedCLIError";
+  }
+}
+exports.AbortedCLIError = AbortedCLIError;
+class CLIAssertionError extends CLIError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CLIAssertionError";
+  }
+}
+exports.CLIAssertionError = CLIAssertionError;
+function logAutomationError(error) {
+  (0, _terminal.terminal)(`^r^+An error occurred while running the API:^:\n`);
+  if (error instanceof _runtimeInterface.AutomationError && error.error) {
+    if (error.error.stack) {
+      const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
+      (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+    } else {
+      (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    }
+  } else {
+    (0, _terminal.terminal)(`^r${error.message}^:\n`);
+  }
+}

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

@@ -0,0 +1,12 @@
+export * from "./api";
+export * from "./auth";
+export * from "./context";
+export * from "./errors";
+export * from "./proxy";
+export * from "./terminal";
+export * from "./timeout";
+export * from "./validation";
+export * from "./intunedJson";
+export * from "./backend";
+export * from "./traces";
+export * from "./wrapper";

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

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _api = require("./api");
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});
+var _auth = require("./auth");
+Object.keys(_auth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _auth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _auth[key];
+    }
+  });
+});
+var _context = require("./context");
+Object.keys(_context).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _context[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _context[key];
+    }
+  });
+});
+var _errors = require("./errors");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _proxy = require("./proxy");
+Object.keys(_proxy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _proxy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _proxy[key];
+    }
+  });
+});
+var _terminal = require("./terminal");
+Object.keys(_terminal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _terminal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _terminal[key];
+    }
+  });
+});
+var _timeout = require("./timeout");
+Object.keys(_timeout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timeout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _timeout[key];
+    }
+  });
+});
+var _validation = require("./validation");
+Object.keys(_validation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validation[key];
+    }
+  });
+});
+var _intunedJson = require("./intunedJson");
+Object.keys(_intunedJson).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _intunedJson[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _intunedJson[key];
+    }
+  });
+});
+var _backend = require("./backend");
+Object.keys(_backend).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _backend[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _backend[key];
+    }
+  });
+});
+var _traces = require("./traces");
+Object.keys(_traces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _traces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _traces[key];
+    }
+  });
+});
+var _wrapper = require("./wrapper");
+Object.keys(_wrapper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _wrapper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _wrapper[key];
+    }
+  });
+});

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

@@ -0,0 +1,39 @@
+export declare const loadIntunedJson: () => Promise<{
+    stealthMode?: {
+        enabled: boolean;
+    } | undefined;
+    workspaceId?: string | undefined;
+    projectName?: string | undefined;
+    metadata?: {
+        defaultJobInput?: Record<string, any> | undefined;
+        defaultRunPlaygroundInput?: Record<string, any> | undefined;
+        testAuthSessionInput?: Record<string, any> | undefined;
+    } | undefined;
+} & {
+    [k: string]: unknown;
+} & ({
+    authSessions: {
+        enabled: false;
+    };
+    apiAccess: {
+        enabled: false;
+    };
+} | {
+    authSessions: {
+        enabled: false;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    apiAccess: {
+        enabled: true;
+    };
+})>;
+export declare const getIntunedSettingsFile: () => Promise<{
+    name: "Intuned.json" | "Intuned.jsonc" | "Intuned.yaml" | "Intuned.yml" | "Intuned.toml";
+    path: string;
+    parse: (content: string) => any;
+}>;
+export declare const getIntunedSettingsFileName: () => Promise<"Intuned.json" | "Intuned.jsonc" | "Intuned.yaml" | "Intuned.yml" | "Intuned.toml">;

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadIntunedJson = exports.getIntunedSettingsFileName = exports.getIntunedSettingsFile = void 0;
+var _errors = require("./errors");
+var _intunedJson = require("../../../common/intunedJson");
+function unwrapped(fn) {
+  return async (...args) => {
+    const result = await fn(...args);
+    if (result.isErr()) {
+      throw new _errors.CLIError(result.error);
+    }
+    return result.value;
+  };
+}
+const loadIntunedJson = exports.loadIntunedJson = unwrapped(_intunedJson.loadIntunedJson);
+const getIntunedSettingsFile = exports.getIntunedSettingsFile = unwrapped(_intunedJson.getIntunedSettingsFile);
+const getIntunedSettingsFileName = exports.getIntunedSettingsFileName = unwrapped(_intunedJson.getIntunedSettingsFileName);

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

@@ -0,0 +1,3 @@
+export declare function promptForProjectName(validate: (name: string) => boolean | string): Promise<string | undefined>;
+export declare function promptForWorkspaceId(): Promise<string>;
+export declare function promptForApiKey(): Promise<string>;

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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.promptForApiKey = promptForApiKey;
+exports.promptForProjectName = promptForProjectName;
+exports.promptForWorkspaceId = promptForWorkspaceId;
+var _prompts = _interopRequireDefault(require("prompts"));
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function promptForProjectName(validate) {
+  const {
+    projectName
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "projectName",
+    message: "Project name (required):",
+    validate
+  });
+  return projectName?.trim();
+}
+const workspaceIdSchema = _zod.z.string().uuid("Workspace ID must be a valid UUID");
+async function promptForWorkspaceId() {
+  const {
+    workspaceId
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "workspaceId",
+    message: "Workspace ID (required):",
+    validate: value => {
+      const parsed = workspaceIdSchema.safeParse(String(value).trim());
+      return parsed.success ? true : parsed.error.errors[0].message;
+    }
+  });
+  return workspaceId.trim();
+}
+const apiKeySchema = _zod.z.string().min(1, "API Key cannot be empty").superRefine((val, ctx) => {
+  if (val.includes(" ")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key cannot contain spaces"
+    });
+  }
+  if (!val.startsWith("in1_")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key must start with 'in1_'"
+    });
+  }
+  if (val.length !== 36) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key must be 36 characters long"
+    });
+  }
+});
+async function promptForApiKey() {
+  const {
+    apiKey
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "apiKey",
+    message: "API Key (required, get it at: https://app.intuned.io/settings/api-keys):",
+    validate: value => {
+      const parsed = apiKeySchema.safeParse(String(value).trim());
+      return parsed.success ? true : parsed.error.errors.map(e => e.message).join(", ");
+    }
+  });
+  return apiKey.trim();
+}

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

@@ -0,0 +1,5 @@
+export declare function parseUrlProxy(proxyUrl: string): {
+    password: string;
+    username: string;
+    server: string;
+} | undefined;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUrlProxy = parseUrlProxy;
+function parseUrlProxy(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    const username = url.username;
+    const password = url.password;
+    const proxy = url.hostname;
+    const port = url.port ? `:${url.port}` : "";
+    const domain = `${url.protocol}//${proxy}${port}`;
+    return {
+      password,
+      username,
+      server: domain
+    };
+  } catch (error) {
+    return;
+  }
+}

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare const terminalStdout: NodeJS.WriteStream & {
+    fd: 2;
+};
+export declare const terminal: import("terminal-kit/Terminal");

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.terminalStdout = exports.terminal = void 0;
+var _terminalKit = require("terminal-kit");
+const terminalStdout = exports.terminalStdout = process.stderr;
+const terminal = exports.terminal = (0, _terminalKit.createTerminal)({
+  appId: "Intuned CLI",
+  appName: "Intuned CLI",
+  stdout: terminalStdout
+});

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

@@ -0,0 +1 @@
+export declare function withTimeout<R>(fn: (abortSignal: AbortSignal) => Promise<R>, timeout: number): Promise<Awaited<R>>;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withTimeout = withTimeout;
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+var _runtimeInterface = require("../../../vendor/runtime-interface");
+function withTimeout(fn, timeout) {
+  let reject;
+  const abortController = new AbortController();
+  const timeoutPromise = new Promise((_, _reject) => {
+    reject = _reject;
+  });
+  const timeoutId = setTimeout(() => {
+    abortController.abort();
+    reject(new _runtimeInterface.AutomationError(new Error("Timed out")));
+  }, timeout);
+  (0, _asyncLocalStorage.getExecutionContext)().timeoutInfo.extendTimeoutCallback = async () => {
+    timeoutId.refresh();
+  };
+  return Promise.race([fn(abortController.signal), timeoutPromise]);
+}

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

@@ -0,0 +1,2 @@
+import { RunApiParameters } from "@intuned/runtime-interface";
+export declare function withCLITrace<T>(fn: (tracing: NonNullable<RunApiParameters["tracing"]>) => T | Promise<T>, id: string | undefined): Promise<T>;

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withCLITrace = withCLITrace;
+var _path = _interopRequireDefault(require("path"));
+var _fsExtra = require("fs-extra");
+var _terminal = require("./terminal");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let _count = 0;
+const _traceDirName = new Date().toISOString();
+function getTracePath(id) {
+  _count++;
+  return _path.default.join("traces", _traceDirName, `${_count}-${id}.zip`);
+}
+async function withCLITrace(fn, id) {
+  if (id === undefined) {
+    return fn({
+      enabled: false
+    });
+  }
+  const tracePath = getTracePath(id);
+  const result = await fn({
+    enabled: true,
+    filePath: tracePath
+  });
+  if (await (0, _fsExtra.exists)(tracePath)) {
+    (0, _terminal.terminal)(`^+Trace saved to^ ^_${tracePath}^:\n`);
+  }
+  return result;
+}

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function logInvalidInput(result: z.SafeParseError<unknown>): void;

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logInvalidInput = logInvalidInput;
+var _errors = require("./errors");
+function logInvalidInput(result) {
+  throw new _errors.CLIError("^r^+Invalid input parameters:^: ^R" + result.error.errors.map(({
+    message
+  }) => `^R${message}^:`).join(", ") + "\n", {
+    autoColor: false
+  });
+}

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function cliCommandWrapper<ZArgs extends z.ZodTuple<any> = z.ZodTuple<[]>, ZOptions extends z.ZodObject<any> = z.ZodObject<Record<string, never>>>(argsSchema: ZArgs | undefined, optionsSchema: ZOptions | undefined, fn: (args: z.infer<ZArgs>, options: z.infer<ZOptions>) => Promise<unknown>): (...input: any[]) => Promise<void>;

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

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cliCommandWrapper = cliCommandWrapper;
+var _terminal = require("./terminal");
+var _runtimeInterface = require("../../../vendor/runtime-interface");
+var _browser = require("./browser");
+var _errors = require("./errors");
+var _zod = require("zod");
+var _validation = require("./validation");
+var _pressAnyKey = _interopRequireDefault(require("press-any-key"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function cliCommandWrapper(argsSchema, optionsSchema, fn) {
+  return async (...input) => {
+    let keepBrowserOpen = false;
+    try {
+      input.pop();
+      const options = input.pop() || {};
+      const args = input;
+      const parseResult = _zod.z.tuple([argsSchema ?? _zod.z.tuple([]), optionsSchema ?? _zod.z.object({})]).safeParse([args, options]);
+      if (!parseResult.success) {
+        return (0, _validation.logInvalidInput)(parseResult);
+      }
+      const [_, parsedOptions] = parseResult.data;
+      const cdpUrl = "cdpUrl" in parsedOptions ? parsedOptions.cdpUrl : undefined;
+      keepBrowserOpen = !cdpUrl && "keepBrowserOpen" in parsedOptions && parsedOptions.keepBrowserOpen === true;
+      if (keepBrowserOpen) {
+        (0, _terminal.terminal)(`^+--keep-open is set, the CLI will not close the last browser after the command completes^:\n`);
+      }
+      await fn(...parseResult.data);
+      if (keepBrowserOpen) {
+        await waitForUserInput();
+      }
+      await (0, _browser.closeCliBrowser)();
+      process.exit(0);
+    } catch (error) {
+      if (error instanceof _errors.AbortedCLIError) {
+        (0, _terminal.terminal)(`\n^r^+Aborted.^:\n`);
+        await (0, _browser.closeCliBrowser)();
+        process.exit(1);
+      }
+      if (error instanceof _errors.CLIError) {
+        if (error.autoColor) {
+          (0, _terminal.terminal)(`^r^+${error.message}^:\n`);
+        } else {
+          (0, _terminal.terminal)(`${error.message}\n`);
+        }
+      } else if (error instanceof _runtimeInterface.AutomationError) {
+        (0, _errors.logAutomationError)(error);
+      } else {
+        (0, _terminal.terminal)(`^r^+An error occurred:^: ^R${error.message}^:\n^r^+Please report this issue to the Intuned team.^:\n`);
+      }
+      if (keepBrowserOpen) {
+        await waitForUserInput();
+      }
+      await (0, _browser.closeCliBrowser)();
+      process.exit(1);
+    }
+  };
+}
+async function waitForUserInput() {
+  if (!(0, _browser.isCliBrowserLaunched)()) return;
+  if (!_terminal.terminalStdout.isTTY) return;
+  (0, _terminal.terminal)("Press any key to continue...");
+  try {
+    await (0, _pressAnyKey.default)("", {
+      ctrlC: "reject",
+      hideMessage: true
+    });
+  } catch {
+    throw new _errors.AbortedCLIError();
+  }
+  (0, _terminal.terminal)("\n");
+}

package/dist/commands/intuned-cli/index.d.ts

@@ -0,0 +1 @@
+export * from "./commands";

package/dist/commands/intuned-cli/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _commands = require("./commands");
+Object.keys(_commands).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _commands[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _commands[key];
+    }
+  });
+});

package/dist/commands/intuned-cli/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/intuned-cli/main.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _constants = require("../../common/constants");
+var _backend = require("./helpers/backend");
+var _intunedJson = require("../../common/intunedJson");
+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); }
+require("../../common/binStartupScript");
+_dotenv.default.config({
+  path: `.env`
+});
+process.env[_constants.CLI_ENV_VAR_KEY] = "true";
+process.env.RUN_ENVIRONMENT = "AUTHORING";
+if (!process.env.FUNCTIONS_DOMAIN) {
+  process.env.FUNCTIONS_DOMAIN = (0, _backend.getBaseUrl)().replace(/\/$/, "");
+}
+void (async () => {
+  const intunedJson = await (0, _intunedJson.loadIntunedJson)();
+  if (intunedJson.isOk() && intunedJson.value.workspaceId) {
+    process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY] = intunedJson.value.workspaceId;
+  }
+  const {
+    program
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require("./commands")));
+  const {
+    withCLIContext
+  } = await Promise.resolve().then(() => _interopRequireWildcard(require("./helpers/context")));
+  await withCLIContext(async () => {
+    program.configureHelp({
+      sortSubcommands: true
+    });
+    program.parse(process.argv);
+  });
+})();