@oneuptime/common 14.0.11 → 14.0.12

package/Server/Types/Workflow/Components/Conditions/IfElse.ts

@@ -1,16 +1,14 @@
-import VMUtil from "../../../../Utils/VM/VMAPI";
 import ComponentCode, { RunOptions, RunReturnType } from "../../ComponentCode";
 import BadDataException from "../../../../../Types/Exception/BadDataException";
-import ReturnResult from "../../../../../Types/IsolatedVM/ReturnResult";
-import { JSONObject, JSONValue } from "../../../../../Types/JSON";
+import { JSONObject } from "../../../../../Types/JSON";
 import ComponentMetadata, {
   Port,
 } from "../../../../../Types/Workflow/Component";
 import ComponentID from "../../../../../Types/Workflow/ComponentID";
 import Components, {
-  ConditionOperator,
-  ConditionValueType,
+  CONDITION_ARGUMENT_IDS,
 } from "../../../../../Types/Workflow/Components/Condition";
+import { evaluateCondition } from "../../../../../Types/Workflow/Components/ConditionEvaluation";
 import CaptureSpan from "../../../../Utils/Telemetry/CaptureSpan";
 
 export default class IfElse extends ComponentCode {
@@ -24,7 +22,7 @@ export default class IfElse extends ComponentCode {
     );
 
     if (!Component) {
-      throw new BadDataException("Custom JavaScript Component not found.");
+      throw new BadDataException("If / Else component not found.");
     }
 
     this.setMetadata(Component);
@@ -55,140 +53,40 @@ export default class IfElse extends ComponentCode {
       throw options.onError(new BadDataException("No port not found"));
     }
 
-    try {
-      /*
-       * Set timeout
-       * Inject args
-       * Inject dependencies
-       */
-
-      // Get explicit types from dropdowns, default to text
-      let input1Type: ConditionValueType =
-        (args["input-1-type"] as ConditionValueType) || ConditionValueType.Text;
-      let input2Type: ConditionValueType =
-        (args["input-2-type"] as ConditionValueType) || ConditionValueType.Text;
-
-      /*
-       * When types differ, coerce both to the more specific type
-       * so comparisons like text "true" == boolean true work correctly.
-       * Priority: Null/Undefined keep as-is, Boolean > Number > Text.
-       */
-      if (input1Type !== input2Type) {
-        type IsNullishFunction = (t: ConditionValueType) => boolean;
-
-        const isNullish: IsNullishFunction = (
-          t: ConditionValueType,
-        ): boolean => {
-          return (
-            t === ConditionValueType.Null || t === ConditionValueType.Undefined
-          );
-        };
-
-        if (!isNullish(input1Type) && !isNullish(input2Type)) {
-          const typePriority: Record<string, number> = {
-            [ConditionValueType.Boolean]: 2,
-            [ConditionValueType.Number]: 1,
-            [ConditionValueType.Text]: 0,
-          };
-
-          const p1: number = typePriority[input1Type] ?? 0;
-          const p2: number = typePriority[input2Type] ?? 0;
-          const commonType: ConditionValueType =
-            p1 >= p2 ? input1Type : input2Type;
-          input1Type = commonType;
-          input2Type = commonType;
-        }
-      }
-
-      type FormatValueFunction = (
-        value: JSONValue,
-        valueType: ConditionValueType,
-      ) => string;
-
-      const formatValue: FormatValueFunction = (
-        value: JSONValue,
-        valueType: ConditionValueType,
-      ): string => {
-        const strValue: string =
-          typeof value === "object"
-            ? JSON.stringify(value)
-            : String(value ?? "");
-
-        switch (valueType) {
-          case ConditionValueType.Boolean:
-            return strValue === "true" ? "true" : "false";
-          case ConditionValueType.Number:
-            return isNaN(Number(strValue)) ? "0" : String(Number(strValue));
-          case ConditionValueType.Null:
-            return "null";
-          case ConditionValueType.Undefined:
-            return "undefined";
-          case ConditionValueType.Text:
-          default:
-            return JSON.stringify(strValue);
-        }
-      };
-
-      args["input-1"] = formatValue(args["input-1"], input1Type);
-      args["input-2"] = formatValue(args["input-2"], input2Type);
-
-      let code: string = `
-                    const input1 = ${(args["input-1"] as string) || ""};
+    /*
+     * The comparison is made here, in TypeScript, the way the old generated
+     * code made it - see ConditionEvaluation. Nothing is written into code
+     * and run, so no setting, nor any value a reference brings in, can run
+     * as a script. A comparison the step does not know fails the run rather
+     * than quietly taking a branch.
+     */
+    let isMet: boolean = false;
 
-                    const input2 = ${(args["input-2"] as string) || ""};
-                    
-                    `;
-
-      if (args["operator"] === ConditionOperator.Contains) {
-        code += `return String(input1).includes(String(input2));`;
-      } else if (args["operator"] === ConditionOperator.DoesNotContain) {
-        code += `return !String(input1).includes(String(input2));`;
-      } else if (args["operator"] === ConditionOperator.StartsWith) {
-        code += `return String(input1).startsWith(String(input2));`;
-      } else if (args["operator"] === ConditionOperator.EndsWith) {
-        code += `return String(input1).endsWith(String(input2));`;
-      } else {
-        code += `return input1 ${(args["operator"] as string) || "=="} input2;`;
-      }
-
-      const returnResult: ReturnResult = await VMUtil.runCodeInSandbox({
-        code,
-        options: {
-          args: args as JSONObject,
-        },
-      });
-
-      const logMessages: string[] = returnResult.logMessages;
-
-      // add to option.log
-      logMessages.forEach((msg: string) => {
-        options.log(msg);
+    try {
+      isMet = evaluateCondition({
+        valueToCheck: args[CONDITION_ARGUMENT_IDS.valueToCheck],
+        operator: args[CONDITION_ARGUMENT_IDS.comparison],
+        compareWith: args[CONDITION_ARGUMENT_IDS.compareWith],
+        valueToCheckType: args[CONDITION_ARGUMENT_IDS.valueToCheckType],
+        compareWithType: args[CONDITION_ARGUMENT_IDS.compareWithType],
       });
-
-      /*
-       * runCodeInSandbox resolves with `scriptError` when the expression
-       * threw or timed out — it no longer rejects. Fail the run instead of
-       * silently taking the "No" branch.
-       */
-      if (returnResult.scriptError) {
-        throw returnResult.scriptError;
-      }
-
-      if (returnResult.returnValue) {
-        return {
-          returnValues: {},
-          executePort: yesPort,
-        };
-      }
-
-      return {
-        returnValues: {},
-        executePort: noPort,
-      };
-    } catch (err: any) {
-      options.log("Error running script");
-      options.log(err.message ? err.message : JSON.stringify(err, null, 2));
-      throw options.onError(err);
+    } catch (err: unknown) {
+      options.log("Could not check the condition.");
+      options.log(err instanceof Error ? err.message : JSON.stringify(err));
+      throw options.onError(
+        err instanceof BadDataException
+          ? err
+          : new BadDataException(
+              err instanceof Error
+                ? err.message
+                : "Could not check the condition.",
+            ),
+      );
     }
+
+    return {
+      returnValues: {},
+      executePort: isMet ? yesPort : noPort,
+    };
   }
 }

package/Server/Types/Workflow/Components/IncomingEmail.ts

@@ -0,0 +1,216 @@
+import ClusterKeyAuthorization from "../../../Middleware/ClusterKeyAuthorization";
+import WorkflowService from "../../../Services/WorkflowService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../../../Utils/Express";
+import logger, { LogAttributes } from "../../../Utils/Logger";
+import {
+  redactGeneratedInboundAddressKeys,
+  redactMonitorSecret,
+} from "../../../Utils/Monitor/MonitorPayloadRedaction";
+import Response from "../../../Utils/Response";
+import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
+import { RunOptions, RunReturnType } from "../ComponentCode";
+import TriggerCode, { ExecuteWorkflowType, InitProps } from "../TriggerCode";
+import Workflow from "../../../../Models/DatabaseModels/Workflow";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../Types/JSON";
+import ObjectID from "../../../../Types/ObjectID";
+import ComponentMetadata, { Port } from "../../../../Types/Workflow/Component";
+import ComponentID from "../../../../Types/Workflow/ComponentID";
+import IncomingEmailComponents from "../../../../Types/Workflow/Components/IncomingEmail";
+import IncomingEmailTrigger, {
+  INCOMING_EMAIL_TRIGGER_DELIVERY_PATH,
+  IncomingEmailTriggerDeliveryStatus,
+  IncomingEmailTriggerEmail,
+} from "../../../../Types/Workflow/IncomingEmailTrigger";
+
+export type ExecuteWorkflowFunction = (
+  executeWorkflow: ExecuteWorkflowType,
+) => Promise<void>;
+
+/*
+ * The Incoming Email trigger: each email sent to a workflow's own address
+ * (workflow-{incomingEmailSecretKey}@{inbound domain}) starts one run of it.
+ *
+ * Mail reaches OneUptime through the inbound email webhook Incoming Email
+ * monitors use (Telemetry's POST /incoming-email/<provider>/<secret>), which
+ * queues it. The queue worker hands each email for a workflow address to the
+ * route registered here, with the cluster key; this is where it becomes a run,
+ * or does not:
+ *
+ *   - the workflow is found by the key in the address and nothing else, so a
+ *     key starts the one workflow it belongs to, in that workflow's project -
+ *     whatever the email itself says;
+ *   - a workflow whose trigger is no longer Incoming Email, or that is off,
+ *     starts nothing (the Webhook trigger refuses a call to a workflow that is
+ *     off the same way);
+ *   - the address is a credential, so the key is masked everywhere in what
+ *     the run is handed - To, Cc, Delivered-To and the rest - before any of
+ *     it is stored in the run's log, which read-only roles can open. So is
+ *     every other monitor or workflow address the same email was sent to.
+ */
+export default class IncomingEmailWorkflowTrigger extends TriggerCode {
+  public constructor() {
+    super();
+
+    const component: ComponentMetadata | undefined =
+      IncomingEmailComponents.find((i: ComponentMetadata) => {
+        return i.id === ComponentID.IncomingEmail;
+      });
+
+    if (!component) {
+      throw new BadDataException("Incoming Email trigger not found.");
+    }
+
+    this.setMetadata(component);
+  }
+
+  /*
+   * Hands the next step every value the trigger promises, whatever the run
+   * started from: a delivered email, or the sender, subject and body typed
+   * into Run Workflow to try the workflow out.
+   */
+  @CaptureSpan()
+  public override async run(
+    args: JSONObject,
+    options: RunOptions,
+  ): Promise<RunReturnType> {
+    const outPort: Port | undefined = this.getMetadata().outPorts.find(
+      (port: Port) => {
+        return port.id === "out";
+      },
+    );
+
+    if (!outPort) {
+      throw options.onError(new BadDataException("Out port not found"));
+    }
+
+    return {
+      returnValues: IncomingEmailTrigger.normalizeReturnValues(args),
+      executePort: outPort,
+    };
+  }
+
+  @CaptureSpan()
+  public override async init(props: InitProps): Promise<void> {
+    props.router.post(
+      INCOMING_EMAIL_TRIGGER_DELIVERY_PATH,
+      ClusterKeyAuthorization.isAuthorizedServiceMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const status: IncomingEmailTriggerDeliveryStatus =
+            await this.deliverEmail({
+              secretKey: req.body?.["secretKey"],
+              email: req.body?.["email"],
+              executeWorkflow: props.executeWorkflow,
+            });
+
+          Response.sendJsonObjectResponse(req, res, { status: status });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  /*
+   * Starts the run one email asks for, or says why it does not. The key is
+   * never logged: it is the address, and logs travel further than the
+   * workflow's own permissions.
+   */
+  @CaptureSpan()
+  public async deliverEmail(data: {
+    secretKey: unknown;
+    email: unknown;
+    executeWorkflow: ExecuteWorkflowFunction;
+  }): Promise<IncomingEmailTriggerDeliveryStatus> {
+    const secretKey: string =
+      typeof data.secretKey === "string"
+        ? data.secretKey.trim().toLowerCase()
+        : "";
+
+    if (!ObjectID.isValidUUID(secretKey)) {
+      return IncomingEmailTriggerDeliveryStatus.NoWorkflow;
+    }
+
+    if (
+      !data.email ||
+      typeof data.email !== "object" ||
+      Array.isArray(data.email)
+    ) {
+      throw new BadDataException("The email to deliver is missing.");
+    }
+
+    const workflow: Workflow | null = await WorkflowService.findOneBy({
+      query: {
+        incomingEmailSecretKey: new ObjectID(secretKey),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        triggerId: true,
+        isEnabled: true,
+        isArchived: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!workflow || !workflow._id) {
+      logger.debug(
+        "Incoming email for a workflow address that no workflow has. Ignoring.",
+      );
+      return IncomingEmailTriggerDeliveryStatus.NoWorkflow;
+    }
+
+    const logAttributes: LogAttributes = {
+      projectId: workflow.projectId?.toString(),
+      workflowId: workflow._id.toString(),
+    };
+
+    if (workflow.triggerId !== ComponentID.IncomingEmail) {
+      logger.debug(
+        "Incoming email for a workflow whose trigger is no longer Incoming Email. Ignoring.",
+        logAttributes,
+      );
+      return IncomingEmailTriggerDeliveryStatus.NotIncomingEmailTrigger;
+    }
+
+    if (workflow.isArchived) {
+      logger.debug(
+        "Incoming email for a workflow that is archived. Ignoring.",
+        logAttributes,
+      );
+      return IncomingEmailTriggerDeliveryStatus.WorkflowArchived;
+    }
+
+    if (!workflow.isEnabled) {
+      logger.debug(
+        "Incoming email for a workflow that is turned off. Ignoring.",
+        logAttributes,
+      );
+      return IncomingEmailTriggerDeliveryStatus.WorkflowDisabled;
+    }
+
+    const returnValues: JSONObject = redactGeneratedInboundAddressKeys(
+      redactMonitorSecret(
+        IncomingEmailTrigger.getReturnValues(
+          data.email as IncomingEmailTriggerEmail,
+        ),
+        secretKey,
+      ),
+      ["monitor", "workflow"],
+    );
+
+    await data.executeWorkflow({
+      workflowId: new ObjectID(workflow._id.toString()),
+      returnValues: returnValues,
+    });
+
+    return IncomingEmailTriggerDeliveryStatus.Scheduled;
+  }
+}

package/Server/Types/Workflow/Components/Index.ts

@@ -20,6 +20,7 @@ import UpdateOneBaseModel from "./BaseModel/UpdateOneBaseModel";
 import IfElse from "./Conditions/IfElse";
 import DiscordSendMessageToChannel from "./Discord/SendMessageToChannel";
 import Email from "./Email";
+import IncomingEmailWorkflowTrigger from "./IncomingEmail";
 import JsonToText from "./JSON/JsonToText";
 import MergeJSON from "./JSON/MergeJson";
 import TextToJSON from "./JSON/TextToJson";
@@ -42,6 +43,7 @@ import ApiPatch from "./API/Patch";
 const Components: Dictionary<ComponentCode> = {
   [ComponentID.AIGenerateText]: new GenerateText(),
   [ComponentID.Webhook]: new WebhookTrigger(),
+  [ComponentID.IncomingEmail]: new IncomingEmailWorkflowTrigger(),
   [ComponentID.SlackSendMessageToChannel]: new SlackSendMessageToChannel(),
   [ComponentID.DiscordSendMessageToChannel]: new DiscordSendMessageToChannel(),
   [ComponentID.MicrosoftTeamsSendMessageToChannel]:
@@ -78,16 +80,22 @@ for (const baseModelService of Services) {
 
   const modelId: string = `${Text.pascalCaseToDashes(model.tableName!)}`;
 
+  // Mirrors BaseModelComponent.getComponents: see EnableWorkflowOn.writeSteps.
+  const offersWriteSteps: boolean = model.enableWorkflowOn.writeSteps !== false;
+
   if (model.enableWorkflowOn.create) {
     Components[`${modelId}-on-create`] = new OnCreateBaseModel(
       baseModelService as any,
     );
-    Components[`${modelId}-create-one`] = new CreateOneBaseModel(
-      baseModelService as any,
-    );
-    Components[`${modelId}-create-many`] = new CreateManyBaseModel(
-      baseModelService as any,
-    );
+
+    if (offersWriteSteps) {
+      Components[`${modelId}-create-one`] = new CreateOneBaseModel(
+        baseModelService as any,
+      );
+      Components[`${modelId}-create-many`] = new CreateManyBaseModel(
+        baseModelService as any,
+      );
+    }
   }
 
   if (model.enableWorkflowOn.read) {
@@ -103,24 +111,30 @@ for (const baseModelService of Services) {
     Components[`${modelId}-on-update`] = new OnUpdateBaseModel(
       baseModelService as any,
     );
-    Components[`${modelId}-update-one`] = new UpdateOneBaseModel(
-      baseModelService as any,
-    );
-    Components[`${modelId}-update-many`] = new UpdateManyBaseModel(
-      baseModelService as any,
-    );
+
+    if (offersWriteSteps) {
+      Components[`${modelId}-update-one`] = new UpdateOneBaseModel(
+        baseModelService as any,
+      );
+      Components[`${modelId}-update-many`] = new UpdateManyBaseModel(
+        baseModelService as any,
+      );
+    }
   }
 
   if (model.enableWorkflowOn.delete) {
     Components[`${modelId}-on-delete`] = new OnDeleteBaseModel(
       baseModelService as any,
     );
-    Components[`${modelId}-delete-one`] = new DeleteOneBaseModel(
-      baseModelService as any,
-    );
-    Components[`${modelId}-delete-many`] = new DeleteManyBaseModel(
-      baseModelService as any,
-    );
+
+    if (offersWriteSteps) {
+      Components[`${modelId}-delete-one`] = new DeleteOneBaseModel(
+        baseModelService as any,
+      );
+      Components[`${modelId}-delete-many`] = new DeleteManyBaseModel(
+        baseModelService as any,
+      );
+    }
   }
 }
 

package/Server/Types/Workflow/Components/Schedule.ts

@@ -17,6 +17,17 @@ import Workflow from "../../../../Models/DatabaseModels/Workflow";
 import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
 import logger from "../../../Utils/Logger";
 
+/*
+ * Whether a scheduled workflow's repeatable job should exist: it is switched
+ * on and it is not archived. Archiving leaves isEnabled as it was, so an
+ * unarchived workflow comes back on its schedule only if it was on before.
+ */
+export const isScheduleLive: (workflow: Workflow) => boolean = (
+  workflow: Workflow,
+): boolean => {
+  return Boolean(workflow.isEnabled) && !workflow.isArchived;
+};
+
 export default class WebhookTrigger extends TriggerCode {
   public constructor() {
     const component: ComponentMetadata | undefined = ScheduleComponents.find(
@@ -43,6 +54,7 @@ export default class WebhookTrigger extends TriggerCode {
         _id: true,
         triggerArguments: true,
         isEnabled: true,
+        isArchived: true,
       },
       props: {
         isRoot: true,
@@ -53,6 +65,12 @@ export default class WebhookTrigger extends TriggerCode {
 
     // query all workflows.
     for (const workflow of workflows) {
+      /*
+       * An archived workflow keeps its isEnabled value (unarchiving gives it
+       * back), so "should this schedule be registered" is both flags.
+       */
+      const shouldRun: boolean = isScheduleLive(workflow);
+
       /*
        * Isolate each workflow: a single workflow whose schedule can't be
        * registered (e.g. an invalid cron, or a transient queue error) must not
@@ -68,7 +86,7 @@ export default class WebhookTrigger extends TriggerCode {
         if (
           workflow.triggerArguments &&
           workflow.triggerArguments["schedule"] &&
-          workflow.isEnabled
+          shouldRun
         ) {
           await props.scheduleWorkflow(
             executeWorkflow,
@@ -76,7 +94,7 @@ export default class WebhookTrigger extends TriggerCode {
           );
         }
 
-        if (!workflow.isEnabled) {
+        if (!shouldRun) {
           await props.removeWorkflow(workflow.id!);
         }
       } catch (err) {
@@ -123,6 +141,7 @@ export default class WebhookTrigger extends TriggerCode {
         _id: true,
         triggerArguments: true,
         isEnabled: true,
+        isArchived: true,
       },
       props: {
         isRoot: true,
@@ -133,6 +152,8 @@ export default class WebhookTrigger extends TriggerCode {
       return;
     }
 
+    const shouldRun: boolean = isScheduleLive(workflow);
+
     if (!this.scheduleWorkflow) {
       return;
     }
@@ -152,7 +173,7 @@ export default class WebhookTrigger extends TriggerCode {
       if (
         workflow.triggerArguments &&
         workflow.triggerArguments["schedule"] &&
-        workflow.isEnabled
+        shouldRun
       ) {
         await this.scheduleWorkflow(
           executeWorkflow,
@@ -164,7 +185,7 @@ export default class WebhookTrigger extends TriggerCode {
         return;
       }
 
-      if (!workflow.isEnabled) {
+      if (!shouldRun) {
         await this.removeWorkflow(workflow.id!);
       }
     } catch (err) {

package/Server/Utils/AI/CodeFix/CodeFixReadiness.ts

@@ -166,7 +166,7 @@ export default class CodeFixReadiness {
       title: "AI agent online",
       detail: anyAgent
         ? `The AI agent "${anyAgent.name || "agent"}" has not reported in — check that its container is running.`
-        : "No agent is available for this project. Install a OneUptime Runner and enable Runs AI Code Fixes on it (Settings > Runners). Cloud: the shared fleet appears here automatically once enabled.",
+        : "No agent is available for this project. Install a OneUptime Runner and enable Runs AI Code Fixes on it (Runbooks > Runners). Cloud: the shared fleet appears here automatically once enabled.",
     };
   }
 

package/Server/Utils/AI/CodeFix/CodeFixRunQueue.ts

@@ -116,7 +116,7 @@ export default class CodeFixRunQueue {
           set: {
             status: AIRunStatus.Error,
             completedAt: OneUptimeDate.getCurrentDate(),
-            errorMessage: `No AI agent picked this task up within ${ORPHANED_QUEUED_TIMEOUT_MINUTES} minutes and none is currently online. Check that a Runner with Runs AI Code Fixes enabled is running (Settings > Runners), then retry the fix from the exception page.`,
+            errorMessage: `No AI agent picked this task up within ${ORPHANED_QUEUED_TIMEOUT_MINUTES} minutes and none is currently online. Check that a Runner with Runs AI Code Fixes enabled is running (Runbooks > Runners), then retry the fix from the exception page.`,
           },
         });