@intuned/runtime-dev 1.3.8-fix.0 → 1.3.9-dev1

package/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/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/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 _runApi = require("../../../common/runApi");
+function withTimeout(fn, timeout) {
+  let reject;
+  const abortController = new AbortController();
+  const timeoutPromise = new Promise((_, _reject) => {
+    reject = _reject;
+  });
+  const timeoutId = setTimeout(() => {
+    abortController.abort();
+    reject(new _runApi.AutomationError(new Error("Timed out")));
+  }, timeout);
+  (0, _asyncLocalStorage.getExecutionContext)().timeoutInfo.extendTimeoutCallback = async () => {
+    timeoutId.refresh();
+  };
+  return Promise.race([fn(abortController.signal), timeoutPromise]);
+}

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

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

package/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/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/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/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/package/dist/commands/intuned-cli/helpers/wrapper.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cliCommandWrapper = cliCommandWrapper;
+var _terminal = require("./terminal");
+var _runApi = require("../../../common/runApi");
+var _browser = require("./browser");
+var _errors = require("./errors");
+var _zod = require("zod");
+var _validation = require("./validation");
+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;
+      keepBrowserOpen = "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.CLIError) {
+        if (error.autoColor) {
+          (0, _terminal.terminal)(`^r^+${error.message}^:\n`);
+        } else {
+          (0, _terminal.terminal)(`${error.message}\n`);
+        }
+      } else if (error instanceof _runApi.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 Enter to continue...");
+  await _terminal.terminal.inputField().promise;
+}

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

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

package/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/package/dist/commands/intuned-cli/main.d.ts

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

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

@@ -0,0 +1,22 @@
+"use strict";
+
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _constants = require("../../common/constants");
+var _backend = require("./helpers/backend");
+var _commands = require("./commands");
+var _helpers = require("./helpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_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(/\/$/, "");
+}
+_commands.program.configureHelp({
+  sortSubcommands: true
+});
+void (0, _helpers.withCLIContext)(async () => {
+  _commands.program.parse(process.argv);
+});

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

@@ -0,0 +1,41 @@
+export interface FileSystemTree {
+    [name: string]: DirectoryNode | FileNode;
+}
+export interface DirectoryNode {
+    directory: FileSystemTree;
+}
+export interface FileNode {
+    file: {
+        /**
+         * The contents of the file, either as a UTF-8 string or as raw binary.
+         */
+        contents: string | Uint8Array;
+    };
+}
+export interface AuthCredentials {
+    workspaceId: string;
+    apiKey: string;
+}
+export declare enum ApiAuthSessionBehavior {
+    PERFORM_CHECK_AND_REFRESH = "PERFORM_CHECK_AND_REFRESH",
+    SKIP_CHECK_AND_REFRESH = "SKIP_CHECK_AND_REFRESH"
+}
+export declare const CHECK_FAILED_ERROR_MESSAGE = "Auth session check failed";
+export type AuthSessionType = "API" | "MANUAL";
+export type AuthSessionMetadata = {
+    createdAt: string;
+    updatedAt: string;
+    authSessionId: string;
+    authSessionType: AuthSessionType;
+    authSessionInput?: Record<string, any>;
+    authSessionProxy?: string;
+    recorderStartUrl?: string;
+    recorderEndUrl?: string;
+};
+export interface SessionStorageState {
+    origin: string;
+    sessionStorage: {
+        name: string;
+        value: string;
+    }[];
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CHECK_FAILED_ERROR_MESSAGE = exports.ApiAuthSessionBehavior = void 0;
+let ApiAuthSessionBehavior = exports.ApiAuthSessionBehavior = function (ApiAuthSessionBehavior) {
+  ApiAuthSessionBehavior["PERFORM_CHECK_AND_REFRESH"] = "PERFORM_CHECK_AND_REFRESH";
+  ApiAuthSessionBehavior["SKIP_CHECK_AND_REFRESH"] = "SKIP_CHECK_AND_REFRESH";
+  return ApiAuthSessionBehavior;
+}({});
+const CHECK_FAILED_ERROR_MESSAGE = exports.CHECK_FAILED_ERROR_MESSAGE = "Auth session check failed";

package/package/dist/commands/ts-check.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/package/dist/commands/ts-check.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+
+var ts = _interopRequireWildcard(require("typescript"));
+var _commander = require("commander");
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _template = require("./common/utils/template");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+_commander.program.description("Check TypeScript types in the project").option("-t, --template <type>", "template to use", "InterfaceTemplate").allowUnknownOption().action(async ({
+  template
+}) => {
+  await (0, _template.moveTemplateFiles)(template);
+  const templateTsConfig = path.resolve(__dirname, "..", "..", "template.tsconfig.json");
+  await fs.copy(templateTsConfig, `./intuned/${template}/tsconfig.json`);
+  checkTypes(template);
+});
+function checkTypes(template) {
+  const configPath = ts.findConfigFile(`./intuned/${template}`, 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);
+  }
+}
+_commander.program.parse(process.argv);

package/package/dist/common/Logger/Logger/index.d.ts

@@ -0,0 +1,12 @@
+import { LogEntry, LogMetadata } from "./types";
+declare class Logger {
+    logFunction(entry: LogEntry): void;
+    private log;
+    trace(message: string, meta?: LogMetadata): void;
+    debug(message: string, meta?: LogMetadata): void;
+    info(message: string, meta?: LogMetadata): void;
+    warn(message: string, meta?: LogMetadata): void;
+    error(message: string, meta?: LogMetadata): void;
+}
+export declare const logger: Logger;
+export {};

package/package/dist/common/Logger/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    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`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/package/dist/common/Logger/Logger/types.d.ts

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

package/package/dist/common/Logger/Logger/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/package/dist/common/Logger/index.d.ts

@@ -0,0 +1,12 @@
+import { LogEntry, LogMetadata } from "./types";
+declare class Logger {
+    logFunction(entry: LogEntry): void;
+    private log;
+    trace(message: string, meta?: LogMetadata): void;
+    debug(message: string, meta?: LogMetadata): void;
+    info(message: string, meta?: LogMetadata): void;
+    warn(message: string, meta?: LogMetadata): void;
+    error(message: string, meta?: LogMetadata): void;
+}
+export declare const logger: Logger;
+export {};

package/package/dist/common/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    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`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/package/dist/common/Logger/types.d.ts

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

package/package/dist/common/Logger/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});