feat: configuration annotations

package.json

@@ -50,6 +50,7 @@
   "dependencies": {
     "@actions/core": "1.10.1",
     "@actions/github": "6.0.0",
+    "@cfworker/json-schema": "2.0.1",
     "@octokit/auth-app": "7.1.0",
     "@octokit/core": "6.1.2",
     "@octokit/plugin-paginate-rest": "11.3.3",

src/github/handlers/push-event.ts

@@ -1,17 +1,12 @@
+import { Validator } from "@cfworker/json-schema";
+import { ValueErrorType } from "@sinclair/typebox/value";
+import { ValueError } from "typebox-validators";
+import YAML, { LineCounter, Node, YAMLError } from "yaml";
 import { GitHubContext } from "../github-context";
+import { PluginConfiguration } from "../types/plugin-configuration";
+import { stateValidationSchema } from "../types/state-validation-payload";
 import { CONFIG_FULL_PATH, getConfigurationFromRepo } from "../utils/config";
-import YAML, { LineCounter, Node, YAMLError } from "yaml";
-import { ValueError } from "typebox-validators";
-import { dispatchWorker, dispatchWorkflow, getDefaultBranch } from "../utils/workflow-dispatch";
-import { PluginChainState, PluginInput, PluginOutput, pluginOutputSchema } from "../types/plugin";
-import { isGithubPlugin, PluginConfiguration } from "../types/plugin-configuration";
-import { Value, ValueErrorType } from "@sinclair/typebox/value";
-import {
-  pluginValidationResponseSchema,
-  StateValidation,
-  pluginValidationResponseSchemaValidator,
-  stateValidationSchema,
-} from "../types/state-validation-payload";
+import { getManifest } from "../utils/plugins";
 
 function constructErrorBody(
   errors: Iterable<ValueError> | (YAML.YAMLError | ValueError)[],
@@ -52,70 +47,6 @@ function constructErrorBody(
   return body;
 }
 
-export async function handleActionValidationWorkflowCompleted(context: GitHubContext<"repository_dispatch">) {
-  const { payload } = context;
-  const { client_payload } = payload;
-  let pluginOutput: PluginOutput;
-  let stateValidation: StateValidation;
-
-  try {
-    pluginOutput = Value.Decode(pluginOutputSchema, client_payload);
-  } catch (error) {
-    console.error("[handleActionValidationWorkflowCompleted]: Cannot decode plugin output", error);
-    throw error;
-  }
-
-  const state = (await context.eventHandler.pluginChainState.get(pluginOutput.state_id)) as PluginChainState<"push">;
-
-  if (!state) {
-    console.error(`[handleActionValidationWorkflowCompleted]: No state found for plugin chain ${pluginOutput.state_id}`);
-    return;
-  }
-
-  console.log("Received Action output result for validation, will process.", pluginOutput.output);
-
-  const errors = pluginOutput.output.errors as ValueError[];
-  try {
-    stateValidation = Value.Decode(stateValidationSchema, state.additionalProperties);
-  } catch (e) {
-    console.error(`[handleActionValidationWorkflowCompleted]: Cannot decode state properties`);
-    throw e;
-  }
-  if (!stateValidation) {
-    console.error(`[handleActionValidationWorkflowCompleted]: State validation is invalid for ${pluginOutput.state_id}`);
-    return;
-  }
-
-  const { rawData, path } = stateValidation;
-  try {
-    if (errors.length && state.eventPayload.repository.owner) {
-      const body = [];
-      if (errors.length) {
-        body.push(
-          ...constructErrorBody(
-            errors.map((err) => ({ ...err, path: `${path}${err.path}` })),
-            rawData as string,
-            state.eventPayload.repository as GitHubContext<"push">["payload"]["repository"],
-            state.eventPayload.after as string
-          )
-        );
-      }
-      await createCommitComment(
-        context,
-        {
-          owner: state.eventPayload.repository.owner.login,
-          repo: state.eventPayload.repository.name,
-          commitSha: state.eventPayload.after as string,
-          userLogin: state.eventPayload.sender?.login,
-        },
-        body
-      );
-    }
-  } catch (e) {
-    console.error("handleActionValidationWorkflowCompleted", e);
-  }
-}
-
 async function createCommitComment(
   context: GitHubContext,
   { owner, repo, commitSha, userLogin }: { owner: string; repo: string; commitSha: string; userLogin?: string },
@@ -152,72 +83,38 @@ async function createCommitComment(
 }
 
 async function checkPluginConfigurations(context: GitHubContext<"push">, config: PluginConfiguration, rawData: string | null) {
-  const { payload, eventHandler } = context;
   const errors: (ValueError | YAML.YAMLError)[] = [];
+  const doc = rawData ? YAML.parseDocument(rawData) : null;
 
   for (let i = 0; i < config.plugins.length; ++i) {
     const { uses } = config.plugins[i];
     for (let j = 0; j < uses.length; ++j) {
       const { plugin, with: args } = uses[j];
-      const isGithubPluginObject = isGithubPlugin(plugin);
-      const stateId = crypto.randomUUID();
-      const token = payload.installation ? await eventHandler.getToken(payload.installation.id) : "";
-      const ref = isGithubPluginObject ? (plugin.ref ?? (await getDefaultBranch(context, plugin.owner, plugin.repo))) : plugin;
-      const inputs = new PluginInput(context.eventHandler, stateId, context.key, payload, args, token, ref);
-
-      if (!isGithubPluginObject) {
-        try {
-          const response = await dispatchWorker(`${plugin}/manifest`, await inputs.getWorkerInputs());
-          const responseWithDefaults = Value.Default(pluginValidationResponseSchema, response) as StateValidation;
-          if (!pluginValidationResponseSchemaValidator.test(responseWithDefaults)) {
-            console.error("Malformed response from the endpoints");
-            for (const err of pluginValidationResponseSchemaValidator.errors(responseWithDefaults)) {
-              console.error(err);
-            }
-          }
-          const decodedResponse = Value.Decode(pluginValidationResponseSchema, responseWithDefaults);
-          if (decodedResponse.errors.length) {
-            errors.push(...decodedResponse.errors.map((err) => ({ ...err, path: `plugins/${i}/uses/${j}/with${err.path}` })));
-          }
-        } catch (e) {
-          errors.push({
-            path: `plugins/${i}/uses/${j}`,
-            message: `Failed to reach plugin endpoint: ${e}`,
-            value: plugin,
-            type: 0,
-            schema: stateValidationSchema,
-          });
-        }
+      const manifest = await getManifest(context, plugin);
+      if (!manifest?.configuration) {
+        errors.push({
+          path: `plugins/${i}/uses/${j}`,
+          message: `Failed to fetch the manifest configuration.`,
+          value: plugin,
+          type: 0,
+          schema: stateValidationSchema,
+        });
       } else {
-        try {
-          await dispatchWorkflow(context, {
-            owner: plugin.owner,
-            repository: plugin.repo,
-            workflowId: "validate-schema.yml",
-            ref: plugin.ref,
-            inputs: inputs.getWorkflowInputs(),
-          });
-          await eventHandler.pluginChainState.put(stateId, {
-            eventPayload: payload,
-            currentPlugin: 0,
-            eventId: "",
-            eventName: "push",
-            inputs: [inputs],
-            outputs: new Array(uses.length),
-            pluginChain: uses,
-            additionalProperties: {
-              rawData,
-              path: `plugins/${i}/uses/${j}/with`,
-            },
-          });
-        } catch (e) {
-          errors.push({
-            path: `plugins/${i}/uses/${j}`,
-            message: `Failed to reach plugin action: ${e}`,
-            value: JSON.stringify(plugin),
-            type: 0,
-            schema: stateValidationSchema,
-          });
+        const validator = new Validator(manifest.configuration, "7", false);
+        const result = validator.validate(args);
+
+        if (!result.valid) {
+          for (const error of result.errors) {
+            const path = error.instanceLocation.replace("#", `plugins/${i}/uses/${j}/with`);
+            const value = doc?.getIn(path.split("/").filter((o) => o));
+            errors.push({
+              path,
+              message: error.error,
+              value,
+              type: 0,
+              schema: stateValidationSchema,
+            });
+          }
         }
       }
     }

src/github/handlers/repository-dispatch.ts

@@ -1,16 +1,13 @@
-import { GitHubContext } from "../github-context";
-import { dispatchWorker, dispatchWorkflow, getDefaultBranch } from "../utils/workflow-dispatch";
 import { Value } from "@sinclair/typebox/value";
-import { PluginInput, PluginChainState, expressionRegex, pluginOutputSchema } from "../types/plugin";
+import { GitHubContext } from "../github-context";
+import { expressionRegex, PluginChainState, PluginInput, pluginOutputSchema } from "../types/plugin";
 import { isGithubPlugin } from "../types/plugin-configuration";
-import { handleActionValidationWorkflowCompleted } from "./push-event";
+import { dispatchWorker, dispatchWorkflow, getDefaultBranch } from "../utils/workflow-dispatch";
 
 export async function repositoryDispatch(context: GitHubContext<"repository_dispatch">) {
   console.log("Repository dispatch event received", context.payload.client_payload);
 
-  if (context.payload.action === "configuration_validation") {
-    return handleActionValidationWorkflowCompleted(context);
-  } else if (context.payload.action !== "return_data_to_ubiquibot_kernel") {
+  if (context.payload.action !== "return_data_to_ubiquibot_kernel") {
     console.log("Skipping non-ubiquibot event");
     return;
   }

src/types/manifest.ts

@@ -14,6 +14,7 @@ export const manifestSchema = T.Object({
   description: T.Optional(T.String({ default: "" })),
   commands: T.Optional(T.Record(T.String(), commandSchema, { default: {} })),
   "ubiquity:listeners": T.Optional(T.Array(runEvent, { default: [] })),
+  configuration: T.Optional(T.Record(T.String(), T.Any(), { default: {} })),
 });
 
 export const manifestValidator = new StandardValidator(manifestSchema);