@intuned/runtime 1.0.5

package/dist/commands/interface/run.js

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAutomationCLI = runAutomationCLI;
+var _commander = require("commander");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _asyncLocalStorage = require("../../common/asyncLocalStorage");
+var net = _interopRequireWildcard(require("net"));
+var _zod = _interopRequireDefault(require("zod"));
+var _runApi = require("../../common/runApi");
+var _enums = require("../../runtime/enums");
+var _unixSocket = require("../common/utils/unixSocket");
+var _promises = require("timers/promises");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+var _formatZodError = require("../../common/formatZodError");
+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; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const startRunApiSchema = _zod.default.object({
+  type: _zod.default.literal("start"),
+  parameters: _runApi.runApiParametersSchema.extend({
+    retrieveSession: _zod.default.boolean(),
+    functionsToken: _zod.default.string().optional(),
+    context: _zod.default.object({
+      jobId: _zod.default.string().optional(),
+      jobRunId: _zod.default.string().optional(),
+      runId: _zod.default.string().optional(),
+      queueId: _zod.default.string().optional()
+    }).optional()
+  })
+});
+const nextRunApiSchema = _zod.default.object({
+  type: _zod.default.literal("next"),
+  parameters: _zod.default.object({
+    value: _zod.default.string()
+  })
+});
+const abortRunApiSchema = _zod.default.object({
+  type: _zod.default.literal("abort"),
+  parameters: _zod.default.object({}).optional()
+});
+const tokenUpdateSchema = _zod.default.object({
+  type: _zod.default.literal("tokenUpdate"),
+  parameters: _zod.default.object({
+    functionsToken: _zod.default.string()
+  })
+});
+const inputSchema = _zod.default.union([startRunApiSchema, nextRunApiSchema, abortRunApiSchema, tokenUpdateSchema]);
+_dotenv.default.config({
+  path: `.env`
+});
+function runAutomationCLI(importFunction) {
+  _commander.program.description("run user automation and communicate using unix socket").argument("<socket-path>", "path to unix socket").action(async socketPath => {
+    let context;
+    const throttleTime = 60 * 1000;
+    let timeoutTimestamp = Date.now();
+    const client = net.createConnection(socketPath);
+    let generator = null;
+    const abortController = new AbortController();
+    client.on("error", err => {
+      var _generator;
+      void ((_generator = generator) === null || _generator === void 0 ? void 0 : _generator.throw(err).catch(() => undefined));
+    });
+    const interruptSignalHandler = async () => {
+      var _generator2;
+      abortController.abort();
+      await (0, _promises.setTimeout)(60_000);
+      void ((_generator2 = generator) === null || _generator2 === void 0 ? void 0 : _generator2.throw(new Error("Interrupted")).catch(() => undefined));
+      client.end();
+      process.exit(1);
+    };
+    process.on("SIGINT", interruptSignalHandler);
+    process.on("SIGTERM", interruptSignalHandler);
+    const jsonUnixSocket = new _unixSocket.JSONUnixSocket(client);
+    const messagesGenerator = jsonUnixSocket.receiveJSON();
+    async function receiveMessages() {
+      const data = await messagesGenerator.next();
+      if (data.done) {
+        return;
+      }
+      const inputParseResult = inputSchema.safeParse(data.value);
+      if (!inputParseResult.success) {
+        console.error("Validation error:", (0, _formatZodError.formatZodError)(inputParseResult.error));
+        return {
+          type: "error",
+          error: new _runApi.InternalInvalidInputError("Invalid input", (0, _formatZodError.formatZodError)(inputParseResult.error))
+        };
+      }
+      const input = inputParseResult.data;
+      return input;
+    }
+    let resultPromise = null;
+    async function handleMessage(message) {
+      if (message.type === "abort") {
+        abortController.abort();
+        return;
+      }
+      if (message.type === "tokenUpdate") {
+        _jwtTokenManager.backendFunctionsTokenManager.token = message.parameters.functionsToken;
+        return;
+      }
+      if (message.type === "start") {
+        generator = (0, _runApi.runApiGenerator)({
+          ...message.parameters,
+          abortSignal: abortController.signal,
+          importFunction
+        });
+        context = {
+          extendedPayloads: [],
+          runEnvironment: message.parameters.runOptions.environment === "standalone" ? _enums.RunEnvironment.DEPLOYED : _enums.RunEnvironment.IDE,
+          timeoutInfo: {
+            extendTimeoutCallback: async () => {
+              if (Date.now() - timeoutTimestamp < throttleTime) return;
+              timeoutTimestamp = Date.now();
+              jsonUnixSocket.sendJSON({
+                type: "extend"
+              });
+            }
+          },
+          ...(message.parameters.context ?? {}),
+          proxy: getProxyUrlFromRunOptions(message.parameters.runOptions)
+        };
+        _jwtTokenManager.backendFunctionsTokenManager.token = message.parameters.functionsToken;
+        resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
+          return await generator.next();
+        });
+        return;
+      }
+      if (message.type === "next") {
+        if (!generator) {
+          throw new Error("generator not started");
+        }
+        resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
+          return await generator.next(message.parameters.value);
+        });
+        return;
+      }
+    }
+    async function handleResult(generatorResult) {
+      if (!generatorResult.done) {
+        jsonUnixSocket.sendJSON({
+          type: "yield",
+          result: generatorResult.value
+        });
+        return false;
+      }
+      const result = generatorResult.value;
+      const success = result.isOk();
+      const resultToSend = success ? result.value : result.error.json;
+      jsonUnixSocket.sendJSON({
+        type: "done",
+        result: resultToSend,
+        success
+      });
+      return true;
+    }
+    let receiveMessagesPromise = receiveMessages();
+    while (true) {
+      const messageOrResult = await Promise.race([receiveMessagesPromise.then(message => ({
+        type: "message",
+        message
+      })), ...(resultPromise ? [resultPromise.then(result => ({
+        type: "result",
+        result
+      }))] : [])]);
+      if (messageOrResult.type === "message") {
+        const {
+          message
+        } = messageOrResult;
+        if (message === undefined) {
+          break;
+        }
+        if (message.type === "error") {
+          jsonUnixSocket.sendJSON({
+            type: "done",
+            result: message.error.json,
+            success: false
+          });
+          break;
+        }
+        await handleMessage(message);
+        receiveMessagesPromise = receiveMessages();
+        continue;
+      }
+      const {
+        result
+      } = messageOrResult;
+      const done = await handleResult(result);
+      if (done) {
+        break;
+      }
+    }
+    if (!client.closed) {
+      client.end();
+      await Promise.race([new Promise(resolve => client.once("close", resolve)), new Promise(resolve => client.once("error", resolve)), (0, _promises.setTimeout)(3000)]);
+    }
+    process.exit(0);
+  });
+  _commander.program.parse(process.argv);
+}
+function getProxyUrlFromRunOptions(runOptions) {
+  if ((runOptions === null || runOptions === void 0 ? void 0 : runOptions.environment) !== "standalone") return undefined;
+  const proxy = runOptions.proxy;
+  if (!proxy) return undefined;
+  const url = new URL(proxy.server);
+  url.username = proxy.username;
+  url.password = proxy.password;
+  return url.toString();
+}
+if (require.main === module) {
+  runAutomationCLI();
+}

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

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

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/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/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/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/dist/common/Logger/Logger/types.js

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

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/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/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/dist/common/Logger/types.js

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