feat: config event handler

src/github/github-event-handler.ts

@@ -2,18 +2,22 @@ import { EmitterWebhookEvent, Webhooks } from "@octokit/webhooks";
 import { customOctokit } from "./github-client";
 import { GitHubContext, SimplifiedContext } from "./github-context";
 import { createAppAuth } from "@octokit/auth-app";
+import { CloudflareKV } from "./utils/cloudflare-kv";
+import { PluginChainState } from "./types/plugin-state-chain";
 
 export type Options = {
   webhookSecret: string;
   appId: string | number;
   privateKey: string;
+  pluginChainState: CloudflareKV<PluginChainState>;
 };
 
 export class GitHubEventHandler {
   public webhooks: Webhooks<SimplifiedContext>;
   public on: Webhooks<SimplifiedContext>["on"];
   public onAny: Webhooks<SimplifiedContext>["onAny"];
   public onError: Webhooks<SimplifiedContext>["onError"];
+  public pluginChainState: CloudflareKV<PluginChainState>;
 
   private _webhookSecret: string;
   private _privateKey: string;
@@ -23,6 +27,7 @@ export class GitHubEventHandler {
     this._privateKey = options.privateKey;
     this._appId = Number(options.appId);
     this._webhookSecret = options.webhookSecret;
+    this.pluginChainState = options.pluginChainState;
 
     this.webhooks = new Webhooks<SimplifiedContext>({
       secret: this._webhookSecret,

src/github/handlers/index.ts

@@ -36,38 +36,48 @@ async function handleEvent(event: EmitterWebhookEvent, eventHandler: InstanceTyp
     return;
   }
 
-  const handler = config.handlers.events[context.key];
+  const pluginChains = config.plugins[context.key];
 
-  if (handler.length === 0) {
+  if (pluginChains.length === 0) {
     console.log(`No handler found for event ${event.name}`);
     return;
   }
 
-  for (const { workflow, settings } of handler) {
-    console.log(`Calling handler for event ${event.name} and workflow ${workflow}`);
+  for (const pluginChain of pluginChains) {
+    // invoke the first plugin in the chain
+    const { plugin, with: settings } = pluginChain.uses[0];
+    console.log(`Calling handler for event ${event.name}`);
 
-    const ref = workflow.ref ?? (await getDefaultBranch(context, workflow.owner, workflow.repository));
+    const id = crypto.randomUUID();
+    await eventHandler.pluginChainState.put(id, {
+      currentPlugin: 0,
+      pluginChain: pluginChain.uses,
+    });
+
+    const ref = plugin.ref ?? (await getDefaultBranch(context, plugin.owner, plugin.repo));
     const token = await eventHandler.getToken(event.payload.installation.id);
-    const inputs = new DelegatedComputeInputs(context.key, event, settings, token, ref);
+    const inputs = new DelegatedComputeInputs(id, context.key, event, settings, token, ref);
 
     await dispatchWorkflow(context, {
-      owner: workflow.owner,
-      repository: workflow.repository,
-      workflowId: workflow.workflowId,
-      ref: workflow.ref,
+      owner: plugin.owner,
+      repository: plugin.repo,
+      workflowId: plugin.workflowId,
+      ref: plugin.ref,
       inputs: inputs.getInputs(),
     });
   }
 }
 
 class DelegatedComputeInputs<T extends EmitterWebhookEventName = EmitterWebhookEventName> {
+  public id: string;
   public eventName: T;
   public event: EmitterWebhookEvent<T>;
   public settings: unknown;
   public authToken: string;
   public ref: string;
 
-  constructor(eventName: T, event: EmitterWebhookEvent<T>, settings: unknown, authToken: string, ref: string) {
+  constructor(id: string, eventName: T, event: EmitterWebhookEvent<T>, settings: unknown, authToken: string, ref: string) {
+    this.id = id;
     this.eventName = eventName;
     this.event = event;
     this.settings = settings;
@@ -77,6 +87,7 @@ class DelegatedComputeInputs<T extends EmitterWebhookEventName = EmitterWebhookE
 
   public getInputs() {
     return {
+      id: this.id,
       eventName: this.eventName,
       event: JSON.stringify(this.event),
       settings: JSON.stringify(this.settings),

src/github/handlers/repository-dispatch.ts

@@ -1,5 +1,63 @@
+import { StaticDecode, Type } from "@sinclair/typebox";
 import { GitHubContext } from "../github-context";
+import { dispatchWorkflow, getDefaultBranch } from "../utils/workflow-dispatch";
+import { Value } from "@sinclair/typebox/value";
 
-export async function repositoryDispatch(event: GitHubContext<"repository_dispatch">) {
-  console.log("Repository dispatch event received", event.payload);
+export async function repositoryDispatch(context: GitHubContext<"repository_dispatch">) {
+  console.log("Repository dispatch event received", context.payload.client_payload);
+
+  const pluginOutput = context.payload.client_payload as PluginOutput;
+
+  if (!Value.Check(pluginOutputSchema, pluginOutput)) {
+    const errors = [...Value.Errors(pluginOutputSchema, pluginOutput)];
+    console.error("Invalid environment variables", errors);
+    throw new Error("Invalid environment variables");
+  }
+
+  const state = await context.eventHandler.pluginChainState.get(pluginOutput.id);
+  if (!state) {
+    console.error("No state found for plugin chain");
+    return;
+  }
+
+  const currentPlugin = state.pluginChain[state.currentPlugin];
+  if (currentPlugin.plugin.owner !== context.payload.repository.owner.login || currentPlugin.plugin.repo !== context.payload.repository.name) {
+    console.error("Plugin chain state does not match payload");
+    return;
+  }
+
+  state.currentPlugin++;
+  await context.eventHandler.pluginChainState.put(pluginOutput.id, state);
+
+  const nextPlugin = state.pluginChain[state.currentPlugin];
+  if (!nextPlugin) {
+    console.log("No more plugins to call");
+    return;
+  }
+
+  console.log("Dispatching next plugin", nextPlugin);
+
+  const inputs = {
+    ...pluginOutput.output,
+    id: pluginOutput.id,
+    settings: JSON.stringify(nextPlugin.with),
+    ref: nextPlugin.plugin.ref ?? (await getDefaultBranch(context, nextPlugin.plugin.owner, nextPlugin.plugin.repo)),
+  };
+
+  await dispatchWorkflow(context, {
+    owner: nextPlugin.plugin.owner,
+    repository: nextPlugin.plugin.repo,
+    ref: nextPlugin.plugin.ref,
+    workflowId: nextPlugin.plugin.workflowId,
+    inputs: inputs,
+  });
 }
+
+const pluginOutputSchema = Type.Object({
+  id: Type.String(),
+  owner: Type.String(),
+  repo: Type.String(),
+  output: Type.Any(),
+});
+
+type PluginOutput = StaticDecode<typeof pluginOutputSchema>;

src/github/types/config.ts

@@ -2,32 +2,58 @@ import { Type as T } from "@sinclair/typebox";
 import { StaticDecode } from "@sinclair/typebox";
 import { githubWebhookEvents } from "./webhook-events";
 
-enum Commands {
-  Start = "start",
-  Stop = "stop",
+const pluginNameRegex = new RegExp("^([0-9a-zA-Z-._]+)/([0-9a-zA-Z-._]+)(?::([0-9a-zA-Z-._]+))?(?:@([0-9a-zA-Z]+))?$");
+
+type GithubPlugin = {
+  owner: string;
+  repo: string;
+  workflowId: string;
+  ref?: string;
+};
+
+function githubPluginType() {
+  return T.Transform(T.String())
+    .Decode((value) => {
+      const matches = value.match(pluginNameRegex);
+      if (!matches) {
+        throw new Error(`Invalid plugin name: ${value}`);
+      }
+      return {
+        owner: matches[1],
+        repo: matches[2],
+        workflowId: matches[3] || "compute.yml",
+        ref: matches[4] || undefined,
+      } as GithubPlugin;
+    })
+    .Encode((value) => {
+      return `${value.owner}/${value.repo}${value.workflowId ? ":" + value.workflowId : ""}${value.ref ? "@" + value.ref : ""}`;
+    });
 }
 
+const pluginChainSchema = T.Array(
+  T.Object({
+    plugin: githubPluginType(),
+    type: T.Union([T.Literal("github")], { default: "github" }),
+    with: T.Optional(T.Unknown()),
+  }),
+  { minItems: 1 }
+);
+
+export type PluginChain = StaticDecode<typeof pluginChainSchema>;
+
 const handlerSchema = T.Array(
   T.Object({
-    workflow: T.Object({
-      owner: T.String(),
-      repository: T.String(),
-      workflowId: T.String(),
-      ref: T.Optional(T.String()),
-    }),
-    settings: T.Optional(T.Unknown()),
+    name: T.Optional(T.String()),
+    description: T.Optional(T.String()),
+    command: T.Optional(T.String()),
+    example: T.Optional(T.String()),
+    uses: pluginChainSchema,
   }),
   { default: [] }
 );
 
 export const configSchema = T.Object({
-  handlers: T.Object(
-    {
-      commands: T.Record(T.Enum(Commands), handlerSchema, { default: {} }),
-      events: T.Record(T.Enum(githubWebhookEvents), handlerSchema, { default: {} }),
-    },
-    { default: {} }
-  ),
+  plugins: T.Record(T.Enum(githubWebhookEvents), handlerSchema, { default: {} }),
 });
 
 export type Config = StaticDecode<typeof configSchema>;

src/github/types/env.ts

@@ -1,4 +1,7 @@
 import { Type as T, type Static } from "@sinclair/typebox";
 
 export const envSchema = T.Object({ WEBHOOK_SECRET: T.String(), APP_ID: T.String(), PRIVATE_KEY: T.String() });
-export type Env = Static<typeof envSchema>;
+
+export type Env = Static<typeof envSchema> & {
+  PLUGIN_CHAIN_STATE: KVNamespace;
+};

src/github/types/plugin-state-chain.ts

@@ -0,0 +1,6 @@
+import { PluginChain } from "./config";
+
+export type PluginChainState = {
+  currentPlugin: number;
+  pluginChain: PluginChain;
+};

src/github/types/webhook-events.ts

@@ -1,9 +1,11 @@
 import { emitterEventNames, EmitterWebhookEventName as GitHubEventClassName } from "@octokit/webhooks";
 
+type EventName = GitHubEventClassName | "*";
+
 type Formatted<T extends string> = T extends `${infer Prefix}.${infer Rest}` ? `${Prefix}_${Formatted<Rest>}` : T;
 
 type GithubEventWebHookEvents = {
-  [K in GitHubEventClassName as Formatted<Uppercase<K>>]: K;
+  [K in EventName as Formatted<Uppercase<K>>]: K;
 };
 
 type Prettify<T> = {
@@ -14,9 +16,12 @@ type Prettify<T> = {
   // eslint-disable-next-line @typescript-eslint/ban-types
 } & {};
 
-export const githubWebhookEvents: Prettify<GithubEventWebHookEvents> = emitterEventNames.reduce((acc: GithubEventWebHookEvents, cur) => {
-  const formatted = cur.replace(/\./g, "_");
-  const upper = formatted.toUpperCase() as Formatted<Uppercase<GitHubEventClassName>>;
-  acc[upper] = cur as Extract<GitHubEventClassName, Uppercase<GitHubEventClassName>>;
-  return acc;
-}, {} as GithubEventWebHookEvents);
+export const githubWebhookEvents: Prettify<GithubEventWebHookEvents> = emitterEventNames.reduce(
+  (acc: GithubEventWebHookEvents, cur) => {
+    const formatted = cur.replace(/\./g, "_");
+    const upper = formatted.toUpperCase() as Formatted<Uppercase<GitHubEventClassName>>;
+    acc[upper] = cur as Extract<GitHubEventClassName, Uppercase<GitHubEventClassName>>;
+    return acc;
+  },
+  { "*": "*" } as GithubEventWebHookEvents
+);

src/github/utils/cloudflare-kv.ts

@@ -0,0 +1,15 @@
+export class CloudflareKV<T> {
+  private _kv: KVNamespace;
+
+  constructor(kv: KVNamespace) {
+    this._kv = kv;
+  }
+
+  get(id: string): Promise<T | null> {
+    return this._kv.get(id, "json");
+  }
+
+  put(id: string, state: T): Promise<void> {
+    return this._kv.put(id, JSON.stringify(state));
+  }
+}

src/worker.ts

@@ -3,14 +3,21 @@ import { Value } from "@sinclair/typebox/value";
 import { GitHubEventHandler } from "./github/github-event-handler";
 import { bindHandlers } from "./github/handlers";
 import { Env, envSchema } from "./github/types/env";
+import { CloudflareKV } from "./github/utils/cloudflare-kv";
+
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     try {
       validateEnv(env);
       const eventName = getEventName(request);
       const signatureSHA256 = getSignature(request);
       const id = getId(request);
-      const eventHandler = new GitHubEventHandler({ webhookSecret: env.WEBHOOK_SECRET, appId: env.APP_ID, privateKey: env.PRIVATE_KEY });
+      const eventHandler = new GitHubEventHandler({
+        webhookSecret: env.WEBHOOK_SECRET,
+        appId: env.APP_ID,
+        privateKey: env.PRIVATE_KEY,
+        pluginChainState: new CloudflareKV(env.PLUGIN_CHAIN_STATE),
+      });
       bindHandlers(eventHandler);
       await eventHandler.webhooks.verifyAndReceive({ id, name: eventName, payload: await request.text(), signature: signatureSHA256 });
       return new Response("ok\n", { status: 200, headers: { "content-type": "text/plain" } });
@@ -19,6 +26,7 @@ export default {
     }
   },
 };
+
 function handleUncaughtError(error: unknown) {
   console.error(error);
   let status = 500;
@@ -38,20 +46,23 @@ function validateEnv(env: Env): void {
     throw new Error("Invalid environment variables");
   }
 }
+
 function getEventName(request: Request): WebhookEventName {
   const eventName = request.headers.get("x-github-event");
   if (!eventName || !emitterEventNames.includes(eventName as WebhookEventName)) {
     throw new Error(`Unsupported or missing "x-github-event" header value: ${eventName}`);
   }
   return eventName as WebhookEventName;
 }
+
 function getSignature(request: Request): string {
   const signatureSHA256 = request.headers.get("x-hub-signature-256");
   if (!signatureSHA256) {
     throw new Error(`Missing "x-hub-signature-256" header`);
   }
   return signatureSHA256;
 }
+
 function getId(request: Request): string {
   const id = request.headers.get("x-github-delivery");
   if (!id) {

wrangler.toml

@@ -2,6 +2,11 @@ name = "ubiquibot-worker"
 main = "src/worker.ts"
 compatibility_date = "2023-12-06"
 
+[env.dev]
+kv_namespaces = [
+    { binding = "PLUGIN_CHAIN_STATE", id = "a50ef0a143e449c087b6be613a84e5ba" },
+]
+
 # Variable bindings. These are arbitrary, plaintext strings (similar to environment variables)
 # Note: Use secrets to store sensitive data.
 # Docs: https://developers.cloudflare.com/workers/platform/environment-variables