@oneuptime/common 9.2.16 → 9.2.18

package/Server/Utils/AI/ScheduledMaintenanceAIContextBuilder.ts

@@ -0,0 +1,345 @@
+import ObjectID from "../../../Types/ObjectID";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceStateTimeline from "../../../Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
+import ScheduledMaintenanceInternalNote from "../../../Models/DatabaseModels/ScheduledMaintenanceInternalNote";
+import ScheduledMaintenancePublicNote from "../../../Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import ScheduledMaintenanceService from "../../Services/ScheduledMaintenanceService";
+import ScheduledMaintenanceStateTimelineService from "../../Services/ScheduledMaintenanceStateTimelineService";
+import ScheduledMaintenanceInternalNoteService from "../../Services/ScheduledMaintenanceInternalNoteService";
+import ScheduledMaintenancePublicNoteService from "../../Services/ScheduledMaintenancePublicNoteService";
+import CaptureSpan from "../Telemetry/CaptureSpan";
+import OneUptimeDate from "../../../Types/Date";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { LLMMessage } from "../LLM/LLMService";
+
+export interface ScheduledMaintenanceContextData {
+  scheduledMaintenance: ScheduledMaintenance;
+  stateTimeline: Array<ScheduledMaintenanceStateTimeline>;
+  internalNotes: Array<ScheduledMaintenanceInternalNote>;
+  publicNotes: Array<ScheduledMaintenancePublicNote>;
+}
+
+export interface AIGenerationContext {
+  contextText: string;
+  systemPrompt: string;
+  messages: Array<LLMMessage>;
+}
+
+export default class ScheduledMaintenanceAIContextBuilder {
+  @CaptureSpan()
+  public static async buildScheduledMaintenanceContext(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<ScheduledMaintenanceContextData> {
+    const scheduledMaintenance: ScheduledMaintenance | null =
+      await ScheduledMaintenanceService.findOneById({
+        id: data.scheduledMaintenanceId,
+        select: {
+          _id: true,
+          title: true,
+          description: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          customFields: true,
+          projectId: true,
+          currentScheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          monitors: {
+            name: true,
+          },
+          labels: {
+            name: true,
+            color: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenance) {
+      throw new Error("Scheduled Maintenance not found");
+    }
+
+    // Fetch state timeline
+    const stateTimeline: Array<ScheduledMaintenanceStateTimeline> =
+      await ScheduledMaintenanceStateTimelineService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          scheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch internal notes
+    const internalNotes: Array<ScheduledMaintenanceInternalNote> =
+      await ScheduledMaintenanceInternalNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch public notes
+    const publicNotes: Array<ScheduledMaintenancePublicNote> =
+      await ScheduledMaintenancePublicNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          postedAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return {
+      scheduledMaintenance,
+      stateTimeline,
+      internalNotes,
+      publicNotes,
+    };
+  }
+
+  @CaptureSpan()
+  public static formatScheduledMaintenanceContextForNote(
+    contextData: ScheduledMaintenanceContextData,
+    noteType: "public" | "internal",
+    template?: string,
+  ): AIGenerationContext {
+    const { scheduledMaintenance, stateTimeline, internalNotes, publicNotes } =
+      contextData;
+
+    let contextText: string = "";
+
+    // Basic scheduled maintenance information
+    contextText += "# Scheduled Maintenance Information\n\n";
+    contextText += `**Title:** ${scheduledMaintenance.title || "N/A"}\n\n`;
+    contextText += `**Description:** ${scheduledMaintenance.description || "N/A"}\n\n`;
+    contextText += `**Current State:** ${scheduledMaintenance.currentScheduledMaintenanceState?.name || "N/A"}\n\n`;
+    contextText += `**Scheduled Start:** ${scheduledMaintenance.startsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.startsAt) : "N/A"}\n\n`;
+    contextText += `**Scheduled End:** ${scheduledMaintenance.endsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.endsAt) : "N/A"}\n\n`;
+    contextText += `**Created At:** ${scheduledMaintenance.createdAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.createdAt) : "N/A"}\n\n`;
+
+    // Affected monitors
+    if (
+      scheduledMaintenance.monitors &&
+      scheduledMaintenance.monitors.length > 0
+    ) {
+      contextText += "**Affected Monitors:** ";
+      contextText += scheduledMaintenance.monitors
+        .map((m: { name?: string }) => {
+          return m.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // Labels
+    if (scheduledMaintenance.labels && scheduledMaintenance.labels.length > 0) {
+      contextText += "**Labels:** ";
+      contextText += scheduledMaintenance.labels
+        .map((l: { name?: string }) => {
+          return l.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // State timeline
+    if (stateTimeline.length > 0) {
+      contextText += "# State Timeline\n\n";
+      for (const timeline of stateTimeline) {
+        const startTime: string = timeline.startsAt
+          ? OneUptimeDate.getDateAsFormattedString(timeline.startsAt)
+          : "N/A";
+        const stateName: string =
+          timeline.scheduledMaintenanceState?.name?.toString() || "Unknown";
+        const createdBy: string =
+          timeline.createdByUser?.name?.toString() ||
+          timeline.createdByUser?.email?.toString() ||
+          "System";
+
+        contextText += `- **${startTime}**: State changed to **${stateName}** by ${createdBy}\n`;
+      }
+      contextText += "\n";
+    }
+
+    // Include internal notes for context (for both note types)
+    if (internalNotes.length > 0) {
+      contextText += "# Internal Notes (Private)\n\n";
+      for (const note of internalNotes) {
+        const noteTime: string = note.createdAt
+          ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+          : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // Public notes
+    if (publicNotes.length > 0) {
+      contextText += "# Public Notes\n\n";
+      for (const note of publicNotes) {
+        const noteTime: string = note.postedAt
+          ? OneUptimeDate.getDateAsFormattedString(note.postedAt)
+          : note.createdAt
+            ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+            : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // System prompt for note generation
+    let systemPrompt: string;
+
+    if (noteType === "public") {
+      if (template) {
+        systemPrompt = `You are an expert technical communicator. Your task is to fill in a public scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Write in a professional, clear, and customer-friendly manner
+- Focus on what customers need to know: timing, impact, and what to expect
+- Avoid technical jargon - keep it understandable for non-technical readers
+- Be concise but informative
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+      } else {
+        systemPrompt = `You are an expert technical communicator. Your task is to generate a public scheduled maintenance note that will be visible to customers on the status page.
+
+The note should:
+1. Be written in a professional, customer-friendly tone
+2. Clearly communicate the current status of the maintenance
+3. Explain what work is being done and any impact on users
+4. Provide timing information (when it started, expected completion, etc.)
+5. Set appropriate expectations
+6. Be concise but informative
+
+DO NOT include:
+- Internal technical details that customers don't need
+- Confidential information
+- Excessive jargon
+
+Write in markdown format for better readability.`;
+      }
+    } else if (template) {
+      // Internal note with template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to fill in an internal scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Be technical and detailed - this is for the internal team
+- Include relevant technical details, progress updates, and observations
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+    } else {
+      // Internal note without template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to generate an internal scheduled maintenance note for the team.
+
+The note should:
+1. Provide technical details about the maintenance progress
+2. Document observations, findings, or actions taken
+3. Include any issues encountered or changes to the plan
+4. Be detailed enough to help team members understand the current status
+5. Use technical language appropriate for the engineering team
+
+Write in markdown format for better readability. Be thorough and technical.`;
+    }
+
+    // Build user message
+    const userMessage: string = template
+      ? `Fill in the template above using ONLY the following scheduled maintenance data. Output only the filled template, nothing else:\n\n${contextText}`
+      : `Based on the following scheduled maintenance data, please generate ${noteType === "public" ? "a customer-facing public" : "an internal technical"} maintenance note:\n\n${contextText}`;
+
+    // Build messages array
+    const messages: Array<LLMMessage> = [
+      {
+        role: "system",
+        content: systemPrompt,
+      },
+      {
+        role: "user",
+        content: userMessage,
+      },
+    ];
+
+    return {
+      contextText,
+      systemPrompt,
+      messages,
+    };
+  }
+}

package/Server/Utils/CodeRepository/GitHub/GitHub.ts

@@ -10,6 +10,29 @@ import OneUptimeDate from "../../../../Types/Date";
 import { JSONArray, JSONObject } from "../../../../Types/JSON";
 import API from "../../../../Utils/API";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
+import {
+  GitHubAppId,
+  GitHubAppPrivateKey,
+  GitHubAppWebhookSecret,
+} from "../../../EnvironmentConfig";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import * as crypto from "crypto";
+
+export interface GitHubRepository {
+  id: number;
+  name: string;
+  fullName: string;
+  private: boolean;
+  htmlUrl: string;
+  description: string | null;
+  defaultBranch: string;
+  ownerLogin: string;
+}
+
+export interface GitHubInstallationToken {
+  token: string;
+  expiresAt: Date;
+}
 
 export default class GitHubUtil extends HostedCodeRepository {
   private getPullRequestFromJSONObject(data: {
@@ -258,4 +281,207 @@ export default class GitHubUtil extends HostedCodeRepository {
       repositoryName: data.repositoryName,
     });
   }
+
+  // GitHub App Authentication Methods
+
+  /**
+   * Generates a JWT for GitHub App authentication
+   * @returns JWT string valid for 10 minutes
+   */
+  @CaptureSpan()
+  public static generateAppJWT(): string {
+    if (!GitHubAppId) {
+      throw new BadDataException(
+        "GITHUB_APP_ID environment variable is not set",
+      );
+    }
+
+    if (!GitHubAppPrivateKey) {
+      throw new BadDataException(
+        "GITHUB_APP_PRIVATE_KEY environment variable is not set",
+      );
+    }
+
+    const now: number = Math.floor(Date.now() / 1000);
+    const payload: JSONObject = {
+      iat: now - 60, // Issued at time (60 seconds in the past to allow for clock drift)
+      exp: now + 600, // Expiration time (10 minutes from now)
+      iss: GitHubAppId,
+    };
+
+    // Create JWT header
+    const header: JSONObject = {
+      alg: "RS256",
+      typ: "JWT",
+    };
+
+    const encodedHeader: string = Buffer.from(JSON.stringify(header)).toString(
+      "base64url",
+    );
+    const encodedPayload: string = Buffer.from(
+      JSON.stringify(payload),
+    ).toString("base64url");
+
+    const signatureInput: string = `${encodedHeader}.${encodedPayload}`;
+
+    // Sign with private key
+    const sign: crypto.Sign = crypto.createSign("RSA-SHA256");
+    sign.update(signatureInput);
+    const signature: string = sign.sign(GitHubAppPrivateKey, "base64url");
+
+    return `${signatureInput}.${signature}`;
+  }
+
+  /**
+   * Gets an installation access token for a GitHub App installation
+   * @param installationId - The GitHub App installation ID
+   * @returns Installation token and expiration date
+   */
+  @CaptureSpan()
+  public static async getInstallationAccessToken(
+    installationId: string,
+  ): Promise<GitHubInstallationToken> {
+    const jwt: string = GitHubUtil.generateAppJWT();
+
+    const url: URL = URL.fromString(
+      `https://api.github.com/app/installations/${installationId}/access_tokens`,
+    );
+
+    const result: HTTPErrorResponse | HTTPResponse<JSONObject> = await API.post(
+      {
+        url: url,
+        data: {},
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+        },
+      },
+    );
+
+    if (result instanceof HTTPErrorResponse) {
+      throw result;
+    }
+
+    return {
+      token: result.data["token"] as string,
+      expiresAt: OneUptimeDate.fromString(result.data["expires_at"] as string),
+    };
+  }
+
+  /**
+   * Lists repositories accessible to a GitHub App installation
+   * @param installationId - The GitHub App installation ID
+   * @returns Array of repositories
+   */
+  @CaptureSpan()
+  public static async listRepositoriesForInstallation(
+    installationId: string,
+  ): Promise<Array<GitHubRepository>> {
+    const tokenData: GitHubInstallationToken =
+      await GitHubUtil.getInstallationAccessToken(installationId);
+
+    const allRepositories: Array<GitHubRepository> = [];
+    let page: number = 1;
+    let hasMore: boolean = true;
+
+    while (hasMore) {
+      const url: URL = URL.fromString(
+        `https://api.github.com/installation/repositories?per_page=100&page=${page}`,
+      );
+
+      const result: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.get({
+          url: url,
+          data: {},
+          headers: {
+            Authorization: `Bearer ${tokenData.token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+          },
+        });
+
+      if (result instanceof HTTPErrorResponse) {
+        throw result;
+      }
+
+      const repositories: JSONArray =
+        (result.data["repositories"] as JSONArray) || [];
+
+      for (const repo of repositories) {
+        const repoData: JSONObject = repo as JSONObject;
+        const owner: JSONObject = repoData["owner"] as JSONObject;
+
+        allRepositories.push({
+          id: repoData["id"] as number,
+          name: repoData["name"] as string,
+          fullName: repoData["full_name"] as string,
+          private: repoData["private"] as boolean,
+          htmlUrl: repoData["html_url"] as string,
+          description: (repoData["description"] as string) || null,
+          defaultBranch: repoData["default_branch"] as string,
+          ownerLogin: owner["login"] as string,
+        });
+      }
+
+      // Check if there are more pages
+      if (repositories.length < 100) {
+        hasMore = false;
+      } else {
+        page++;
+      }
+    }
+
+    return allRepositories;
+  }
+
+  /**
+   * Verifies a GitHub webhook signature
+   * @param payload - The raw request body
+   * @param signature - The X-Hub-Signature-256 header value
+   * @returns true if signature is valid
+   */
+  public static verifyWebhookSignature(
+    payload: string,
+    signature: string,
+  ): boolean {
+    if (!GitHubAppWebhookSecret) {
+      logger.warn(
+        "GITHUB_APP_WEBHOOK_SECRET is not set, skipping verification",
+      );
+      return true;
+    }
+
+    const expectedSignature: string = `sha256=${crypto
+      .createHmac("sha256", GitHubAppWebhookSecret)
+      .update(payload)
+      .digest("hex")}`;
+
+    try {
+      return crypto.timingSafeEqual(
+        Buffer.from(signature) as Uint8Array,
+        Buffer.from(expectedSignature) as Uint8Array,
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Gets the GitHub App installation URL for a project to install the app
+   * @returns The installation URL
+   */
+  public static getAppInstallationUrl(): string {
+    if (!GitHubAppId) {
+      throw new BadDataException(
+        "GITHUB_APP_ID environment variable is not set",
+      );
+    }
+
+    /*
+     * This is the standard GitHub App installation URL format
+     * The app slug would typically come from another env var, but we can use the client ID approach
+     */
+    return `https://github.com/apps`;
+  }
 }