Merge development into main

.cspell.json

@@ -4,7 +4,7 @@
   "ignorePaths": ["**/*.json", "**/*.css", "node_modules", "**/*.log"],
   "useGitignore": true,
   "language": "en",
-  "words": ["dataurl", "devpool", "outdir", "servedir", "typebox"],
+  "words": ["dataurl", "devpool", "outdir", "servedir", "typebox", "gentlementlegen", "workerd"],
   "dictionaries": ["typescript", "node", "software-terms"],
   "import": ["@cspell/dict-typescript/cspell-ext.json", "@cspell/dict-node/cspell-ext.json", "@cspell/dict-software-terms"],
   "ignoreRegExpList": ["[0-9a-fA-F]{6}"]

README.md

@@ -17,6 +17,10 @@ The `createActionsPlugin` function allows users to create plugins that will be a
 
 The `createPlugin` function enables users to create a plugin that will run on Cloudflare Workers environment.
 
+### `postComment`
+
+The `postComment` function enables users to easily post a comment to an issue, a pull-request, or a pull request review thread.
+
 ## Getting Started
 
 To set up the project locally, `bun` is the preferred package manager.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubiquity-os/plugin-sdk",
-  "version": "0.0.0",
+  "version": "1.1.1",
   "description": "SDK for plugin support.",
   "author": "Ubiquity DAO",
   "license": "MIT",
@@ -110,7 +110,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-check-file": "^2.8.0",
     "eslint-plugin-prettier": "^5.2.1",
-    "eslint-plugin-sonarjs": "^2.0.4",
+    "eslint-plugin-sonarjs": "^3.0.1",
     "husky": "^9.0.11",
     "jest": "^29.7.0",
     "jest-junit": "^16.0.0",
@@ -129,7 +129,7 @@
   },
   "lint-staged": {
     "*.ts": [
-      "bun prettier --write",
+      "prettier --write",
       "eslint --fix"
     ],
     "src/**.{ts,json}": [

src/actions.ts

@@ -5,13 +5,14 @@ import { Type as T } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import { LogReturn, Logs } from "@ubiquity-os/ubiquity-os-logger";
 import { config } from "dotenv";
+import { postComment } from "./comment";
 import { Context } from "./context";
 import { customOctokit } from "./octokit";
 import { verifySignature } from "./signature";
 import { commandCallSchema } from "./types/command";
 import { HandlerReturn } from "./types/sdk";
 import { jsonType } from "./types/util";
-import { getPluginOptions, Options, sanitizeMetadata } from "./util";
+import { getPluginOptions, Options } from "./util";
 
 config();
 
@@ -120,28 +121,11 @@ export async function createActionsPlugin<TConfig = unknown, TEnv = unknown, TCo
     }
 
     if (pluginOptions.postCommentOnError && loggerError) {
-      await postErrorComment(context, loggerError);
+      await postComment(context, loggerError);
     }
   }
 }
 
-async function postErrorComment(context: Context, error: LogReturn) {
-  if ("issue" in context.payload && context.payload.repository?.owner?.login) {
-    await context.octokit.rest.issues.createComment({
-      owner: context.payload.repository.owner.login,
-      repo: context.payload.repository.name,
-      issue_number: context.payload.issue.number,
-      body: `${error.logMessage.diff}\n<!--\n${getGithubWorkflowRunUrl()}\n${sanitizeMetadata(error.metadata)}\n-->`,
-    });
-  } else {
-    context.logger.info("Cannot post error comment because issue is not found in the payload");
-  }
-}
-
-function getGithubWorkflowRunUrl() {
-  return `${github.context.payload.repository?.html_url}/actions/runs/${github.context.runId}`;
-}
-
 async function returnDataToKernel(repoToken: string, stateId: string, output: HandlerReturn) {
   const octokit = new customOctokit({ auth: repoToken });
   await octokit.rest.repos.createDispatchEvent({

src/comment.ts

@@ -1,35 +1,106 @@
+import { LogReturn, Metadata } from "@ubiquity-os/ubiquity-os-logger";
 import { Context } from "./context";
-import { LogReturn } from "@ubiquity-os/ubiquity-os-logger";
+import { PluginRuntimeInfo } from "./helpers/runtime-info";
 import { sanitizeMetadata } from "./util";
 
-const HEADER_NAME = "Ubiquity";
+const HEADER_NAME = "UbiquityOS";
+
+export interface CommentOptions {
+  /*
+   * Should the comment be posted as send within the log, without adding any sort of formatting.
+   */
+  raw?: boolean;
+  /*
+   * Should the previously posted comment be reused instead of posting a new comment.
+   */
+  updateComment?: boolean;
+}
+
+export type PostComment = {
+  (context: Context, message: LogReturn | Error, options?: CommentOptions): Promise<void>;
+  lastCommentId?: number;
+};
 
 /**
  * Posts a comment on a GitHub issue if the issue exists in the context payload, embedding structured metadata to it.
  */
-export async function postComment(context: Context, message: LogReturn) {
-  if ("issue" in context.payload && context.payload.repository?.owner?.login) {
-    const metadata = createStructuredMetadata(message.metadata?.name, message);
-    await context.octokit.rest.issues.createComment({
-      owner: context.payload.repository.owner.login,
-      repo: context.payload.repository.name,
-      issue_number: context.payload.issue.number,
-      body: [message.logMessage.diff, metadata].join("\n"),
-    });
+export const postComment: PostComment = async function (
+  context: Context,
+  message: LogReturn | Error,
+  options: CommentOptions = { updateComment: true, raw: false }
+) {
+  let issueNumber;
+
+  if ("issue" in context.payload) {
+    issueNumber = context.payload.issue.number;
+  } else if ("pull_request" in context.payload) {
+    issueNumber = context.payload.pull_request.number;
+  } else if ("discussion" in context.payload) {
+    issueNumber = context.payload.discussion.number;
   } else {
-    context.logger.info("Cannot post comment because issue is not found in the payload");
+    context.logger.info("Cannot post comment because issue is not found in the payload.");
+    return;
   }
-}
 
-function createStructuredMetadata(className: string | undefined, logReturn: LogReturn) {
-  const logMessage = logReturn.logMessage;
-  const metadata = logReturn.metadata;
+  if ("repository" in context.payload && context.payload.repository?.owner?.login) {
+    const body = await createStructuredMetadataWithMessage(context, message, options);
+    if (options.updateComment && postComment.lastCommentId) {
+      await context.octokit.rest.issues.updateComment({
+        owner: context.payload.repository.owner.login,
+        repo: context.payload.repository.name,
+        comment_id: postComment.lastCommentId,
+        body: body,
+      });
+    } else {
+      const commentData = await context.octokit.rest.issues.createComment({
+        owner: context.payload.repository.owner.login,
+        repo: context.payload.repository.name,
+        issue_number: issueNumber,
+        body: body,
+      });
+      postComment.lastCommentId = commentData.data.id;
+    }
+  } else {
+    context.logger.info("Cannot post comment because repository is not found in the payload.", { payload: context.payload });
+  }
+};
+
+async function createStructuredMetadataWithMessage(context: Context, message: LogReturn | Error, options: CommentOptions) {
+  let logMessage;
+  let callingFnName;
+  let instigatorName;
+  let metadata: Metadata;
 
+  if (message instanceof Error) {
+    metadata = {
+      message: message.message,
+      name: message.name,
+      stack: message.stack,
+    };
+    callingFnName = message.stack?.split("\n")[2]?.match(/at (\S+)/)?.[1] ?? "anonymous";
+    logMessage = context.logger.error(message.message).logMessage;
+  } else if (message.metadata) {
+    metadata = {
+      message: message.metadata.message,
+      stack: message.metadata.stack || message.metadata.error?.stack,
+      caller: message.metadata.caller || message.metadata.error?.stack?.split("\n")[2]?.match(/at (\S+)/)?.[1],
+    };
+    logMessage = message.logMessage;
+    callingFnName = metadata.caller;
+  } else {
+    metadata = { ...message };
+  }
   const jsonPretty = sanitizeMetadata(metadata);
-  const stack = logReturn.metadata?.stack;
-  const stackLine = (Array.isArray(stack) ? stack.join("\n") : stack)?.split("\n")[2] ?? "";
-  const caller = stackLine.match(/at (\S+)/)?.[1] ?? "";
-  const ubiquityMetadataHeader = `<!-- ${HEADER_NAME} - ${className} - ${caller} - ${metadata?.revision}`;
+
+  if ("installation" in context.payload && context.payload.installation && "account" in context.payload.installation) {
+    instigatorName = context.payload.installation?.account?.name;
+  } else {
+    instigatorName = context.payload.sender?.login || HEADER_NAME;
+  }
+  const runUrl = PluginRuntimeInfo.getInstance().runUrl;
+  const version = await PluginRuntimeInfo.getInstance().version;
+
+  const ubiquityMetadataHeader = `<!-- ${HEADER_NAME} - ${runUrl} - ${callingFnName} - ${version} - @${instigatorName}`;
 
   let metadataSerialized: string;
   const metadataSerializedVisible = ["```json", jsonPretty, "```"].join("\n");
@@ -44,5 +115,5 @@ function createStructuredMetadata(className: string | undefined, logReturn: LogR
   }
 
   // Add carriage returns to avoid any formatting issue
-  return `\n${metadataSerialized}\n`;
+  return `${options.raw ? logMessage?.raw : logMessage?.diff}\n\n${metadataSerialized}\n`;
 }

src/helpers/runtime-info.ts

@@ -0,0 +1,47 @@
+import github from "@actions/github";
+import { getRuntimeKey } from "hono/adapter";
+
+export abstract class PluginRuntimeInfo {
+  private static _instance: PluginRuntimeInfo | null = null;
+  protected _env: Record<string, unknown> = {};
+
+  protected constructor(env?: Record<string, string>) {
+    if (env) {
+      this._env = env;
+    }
+  }
+
+  public static getInstance(env?: Record<string, string>) {
+    if (!PluginRuntimeInfo._instance) {
+      PluginRuntimeInfo._instance = getRuntimeKey() === "workerd" ? new CfRuntimeInfo(env) : new NodeRuntimeInfo(env);
+    }
+    return PluginRuntimeInfo._instance;
+  }
+
+  public abstract get version(): Promise<string>;
+  public abstract get runUrl(): string;
+}
+
+export class CfRuntimeInfo extends PluginRuntimeInfo {
+  public get version(): Promise<string> {
+    // See also https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/
+    return Promise.resolve((this._env.CLOUDFLARE_VERSION_METADATA as { id: string })?.id ?? "CLOUDFLARE_VERSION_METADATA");
+  }
+  public get runUrl(): string {
+    const accountId = this._env.CLOUDFLARE_ACCOUNT_ID ?? "<missing-cloudflare-account-id>";
+    const workerName = this._env.CLOUDFLARE_WORKER_NAME;
+    const toTime = Date.now() + 60000;
+    const fromTime = Date.now() - 60000;
+    const timeParam = encodeURIComponent(`{"type":"absolute","to":${toTime},"from":${fromTime}}`);
+    return `https://dash.cloudflare.com/${accountId}/workers/services/view/${workerName}/production/observability/logs?granularity=0&time=${timeParam}`;
+  }
+}
+
+export class NodeRuntimeInfo extends PluginRuntimeInfo {
+  public get version() {
+    return Promise.resolve(github.context.sha);
+  }
+  public get runUrl() {
+    return github.context.payload.repository ? `${github.context.payload.repository?.html_url}/actions/runs/${github.context.runId}` : "http://localhost";
+  }
+}

src/server.ts

@@ -7,6 +7,7 @@ import { env as honoEnv } from "hono/adapter";
 import { HTTPException } from "hono/http-exception";
 import { postComment } from "./comment";
 import { Context } from "./context";
+import { PluginRuntimeInfo } from "./helpers/runtime-info";
 import { customOctokit } from "./octokit";
 import { verifySignature } from "./signature";
 import { Manifest } from "./types/manifest";
@@ -79,6 +80,9 @@ export function createPlugin<TConfig = unknown, TEnv = unknown, TCommand = unkno
       env = ctx.env as TEnv;
     }
 
+    const workerName = new URL(inputs.ref).hostname.split(".")[0];
+    PluginRuntimeInfo.getInstance({ ...env, CLOUDFLARE_WORKER_NAME: workerName });
+
     let command: TCommand | null = null;
     if (inputs.command && pluginOptions.commandSchema) {
       try {
@@ -107,10 +111,8 @@ export function createPlugin<TConfig = unknown, TEnv = unknown, TCommand = unkno
     } catch (error) {
       console.error(error);
 
-      let loggerError: LogReturn | null;
-      if (error instanceof Error) {
-        loggerError = context.logger.error(`Error: ${error}`, { error: error });
-      } else if (error instanceof LogReturn) {
+      let loggerError: LogReturn | Error | null;
+      if (error instanceof Error || error instanceof LogReturn) {
         loggerError = error;
       } else {
         loggerError = context.logger.error(`Error: ${error}`);

tests/comment.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import { Logs } from "@ubiquity-os/ubiquity-os-logger";
+import { Context, postComment } from "../src";
+
+describe("Post comment tests", () => {
+  it("Should reuse a message if the reuse option is true", async () => {
+    const logger = new Logs("debug");
+    const createComment = jest.fn(() => ({
+      data: {
+        id: 1234,
+      },
+    }));
+    const updateComment = jest.fn(() => ({
+      data: {
+        id: 1234,
+      },
+    }));
+    jest.unstable_mockModule("@octokit/core", () => ({
+      Octokit: jest.fn(() => ({
+        rest: {
+          issues: {
+            createComment,
+            updateComment,
+          },
+        },
+      })),
+    }));
+    const { Octokit } = await import("@octokit/core");
+    const ctx = {
+      payload: {
+        issue: {
+          number: 1,
+        },
+        repository: {
+          owner: {
+            login: "ubiquity-os",
+          },
+          name: "plugin-sdk",
+        },
+      },
+      logger,
+      octokit: new Octokit(),
+    } as unknown as Context;
+    await postComment(ctx, logger.ok("test"), { updateComment: true });
+    await postComment(ctx, logger.ok("test 2"), { updateComment: true });
+    expect(createComment).toHaveBeenCalledWith({
+      owner: "ubiquity-os",
+      repo: "plugin-sdk",
+      issue_number: 1,
+      body: expect.anything(),
+    });
+    expect(updateComment).toHaveBeenCalledWith({
+      owner: "ubiquity-os",
+      repo: "plugin-sdk",
+      comment_id: 1234,
+      body: expect.anything(),
+    });
+  });
+});