@ubiquity-os/plugin-sdk 3.4.6 → 3.5.1

package/dist/configuration.js

@@ -0,0 +1,340 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/configuration.ts
+var configuration_exports = {};
+__export(configuration_exports, {
+  CONFIG_DEV_FULL_PATH: () => CONFIG_DEV_FULL_PATH,
+  CONFIG_ORG_REPO: () => CONFIG_ORG_REPO,
+  CONFIG_PROD_FULL_PATH: () => CONFIG_PROD_FULL_PATH,
+  ConfigurationHandler: () => ConfigurationHandler
+});
+module.exports = __toCommonJS(configuration_exports);
+var import_value = require("@sinclair/typebox/value");
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_node_buffer = require("node:buffer");
+
+// src/configuration/schema.ts
+var import_webhooks = require("@octokit/webhooks");
+var import_typebox = require("@sinclair/typebox");
+var pluginNameRegex = new RegExp("^([0-9a-zA-Z-._]+)\\/([0-9a-zA-Z-._]+)(?::([0-9a-zA-Z-._]+))?(?:@([0-9a-zA-Z-._]+(?:\\/[0-9a-zA-Z-._]+)*))?$");
+function parsePluginIdentifier(value) {
+  const matches = pluginNameRegex.exec(value);
+  if (!matches) {
+    throw new Error(`Invalid plugin name: ${value}`);
+  }
+  return {
+    owner: matches[1],
+    repo: matches[2],
+    workflowId: matches[3] || "compute.yml",
+    ref: matches[4] || void 0
+  };
+}
+function stringLiteralUnion(values) {
+  const literals = values.map((value) => import_typebox.Type.Literal(value));
+  return import_typebox.Type.Union(literals);
+}
+var emitterType = stringLiteralUnion(import_webhooks.emitterEventNames);
+var runsOnSchema = import_typebox.Type.Array(emitterType, { default: [] });
+var pluginSettingsSchema = import_typebox.Type.Union(
+  [
+    import_typebox.Type.Null(),
+    import_typebox.Type.Object(
+      {
+        with: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Unknown(), { default: {} }),
+        runsOn: import_typebox.Type.Optional(runsOnSchema),
+        skipBotEvents: import_typebox.Type.Optional(import_typebox.Type.Boolean())
+      },
+      { default: {} }
+    )
+  ],
+  { default: null }
+);
+var configSchema = import_typebox.Type.Object(
+  {
+    plugins: import_typebox.Type.Record(import_typebox.Type.String(), pluginSettingsSchema, { default: {} })
+  },
+  {
+    additionalProperties: true
+  }
+);
+
+// src/types/manifest.ts
+var import_typebox2 = require("@sinclair/typebox");
+var import_webhooks2 = require("@octokit/webhooks");
+var runEvent = import_typebox2.Type.Union(import_webhooks2.emitterEventNames.map((o) => import_typebox2.Type.Literal(o)));
+var exampleCommandExecutionSchema = import_typebox2.Type.Object({
+  commandInvocation: import_typebox2.Type.String({ minLength: 1 }),
+  githubContext: import_typebox2.Type.Optional(import_typebox2.Type.Record(import_typebox2.Type.String(), import_typebox2.Type.Any())),
+  expectedToolCallResult: import_typebox2.Type.Object({
+    function: import_typebox2.Type.String({ minLength: 1 }),
+    parameters: import_typebox2.Type.Record(import_typebox2.Type.String(), import_typebox2.Type.Any())
+  })
+});
+var commandSchema = import_typebox2.Type.Object({
+  description: import_typebox2.Type.String({ minLength: 1 }),
+  "ubiquity:example": import_typebox2.Type.String({ minLength: 1 }),
+  parameters: import_typebox2.Type.Optional(import_typebox2.Type.Record(import_typebox2.Type.String(), import_typebox2.Type.Any())),
+  examples: import_typebox2.Type.Optional(import_typebox2.Type.Array(exampleCommandExecutionSchema, { default: [] }))
+});
+var manifestSchema = import_typebox2.Type.Object({
+  name: import_typebox2.Type.String({ minLength: 1 }),
+  short_name: import_typebox2.Type.String({ minLength: 1 }),
+  description: import_typebox2.Type.Optional(import_typebox2.Type.String({ default: "" })),
+  commands: import_typebox2.Type.Optional(import_typebox2.Type.Record(import_typebox2.Type.String({ pattern: "^[A-Za-z-_]+$" }), commandSchema, { default: {} })),
+  "ubiquity:listeners": import_typebox2.Type.Optional(import_typebox2.Type.Array(runEvent, { default: [] })),
+  configuration: import_typebox2.Type.Optional(import_typebox2.Type.Record(import_typebox2.Type.String(), import_typebox2.Type.Any(), { default: {} })),
+  skipBotEvents: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: true }))
+});
+
+// src/configuration.ts
+var CONFIG_PROD_FULL_PATH = ".github/.ubiquity-os.config.yml";
+var CONFIG_DEV_FULL_PATH = ".github/.ubiquity-os.config.dev.yml";
+var CONFIG_ORG_REPO = ".ubiquity-os";
+var ConfigurationHandler = class {
+  constructor(_logger, _octokit) {
+    this._logger = _logger;
+    this._octokit = _octokit;
+  }
+  _manifestCache = {};
+  _manifestPromiseCache = {};
+  /**
+   *  Retrieves the configuration for the current plugin based on its manifest.
+   *  @param manifest - The plugin manifest containing the `short_name` identifier
+   *  @param location - Optional repository location (`owner/repo`)
+   *  @returns The plugin's configuration or null if not found
+   **/
+  async getSelfConfiguration(manifest, location) {
+    const cfg = await this.getConfiguration(location);
+    const name = manifest.short_name.split("@")[0];
+    const selfConfig = Object.keys(cfg.plugins).find((key) => new RegExp(`^${name}(?:$|@.+)`).exec(key.replace(/:[^@]+/, "")));
+    return selfConfig && cfg.plugins[selfConfig] ? cfg.plugins[selfConfig]["with"] : null;
+  }
+  /**
+   * Retrieves and merges configuration from organization and repository levels.
+   * @param location - Optional repository location (`owner` and `repo`). If not provided, returns the default configuration.
+   * @returns The merged plugin configuration with resolved plugin settings.
+   */
+  async getConfiguration(location) {
+    const defaultConfiguration = import_value.Value.Decode(configSchema, import_value.Value.Default(configSchema, {}));
+    if (!location) {
+      this._logger.debug("No location was provided, using the default configuration");
+      return defaultConfiguration;
+    }
+    const { owner, repo } = location;
+    let mergedConfiguration = defaultConfiguration;
+    this._logger.debug("Fetching configurations from the organization and repository", {
+      orgRepo: `${owner}/${CONFIG_ORG_REPO}`,
+      repo: `${owner}/${repo}`
+    });
+    const orgConfig = await this._getConfigurationFromRepo(owner, CONFIG_ORG_REPO);
+    const repoConfig = await this._getConfigurationFromRepo(owner, repo);
+    if (orgConfig.config) {
+      mergedConfiguration = this.mergeConfigurations(mergedConfiguration, orgConfig.config);
+    }
+    if (repoConfig.config) {
+      mergedConfiguration = this.mergeConfigurations(mergedConfiguration, repoConfig.config);
+    }
+    const resolvedPlugins = {};
+    this._logger.debug("Found plugins enabled", { repo: `${owner}/${repo}`, plugins: Object.keys(mergedConfiguration.plugins).length });
+    for (const [pluginKey, pluginSettings] of Object.entries(mergedConfiguration.plugins)) {
+      let pluginIdentifier;
+      try {
+        pluginIdentifier = parsePluginIdentifier(pluginKey);
+      } catch (error) {
+        this._logger.error("Invalid plugin identifier; skipping", { plugin: pluginKey, err: error });
+        continue;
+      }
+      const manifest = await this.getManifest(pluginIdentifier);
+      let runsOn = pluginSettings?.runsOn ?? [];
+      let shouldSkipBotEvents = pluginSettings?.skipBotEvents;
+      if (manifest) {
+        if (!runsOn.length) {
+          runsOn = manifest["ubiquity:listeners"] ?? [];
+        }
+        if (shouldSkipBotEvents === void 0) {
+          shouldSkipBotEvents = manifest.skipBotEvents ?? true;
+        }
+      } else {
+        shouldSkipBotEvents = true;
+      }
+      resolvedPlugins[pluginKey] = {
+        ...pluginSettings,
+        with: pluginSettings?.with ?? {},
+        runsOn,
+        skipBotEvents: shouldSkipBotEvents
+      };
+    }
+    return {
+      ...mergedConfiguration,
+      plugins: resolvedPlugins
+    };
+  }
+  async _getConfigurationFromRepo(owner, repository) {
+    const rawData = await this._download({
+      repository,
+      owner
+    });
+    this._logger.debug("Downloaded configuration file", { owner, repository });
+    if (!rawData) {
+      this._logger.debug("No raw configuration data", { owner, repository });
+      return { config: null, errors: null, rawData: null };
+    }
+    const { yaml, errors } = this._parseYaml(rawData);
+    const targetRepoConfiguration = yaml;
+    this._logger.debug("Decoding configuration", { owner, repository });
+    if (targetRepoConfiguration) {
+      try {
+        const configSchemaWithDefaults = import_value.Value.Default(configSchema, targetRepoConfiguration);
+        const errors2 = import_value.Value.Errors(configSchema, configSchemaWithDefaults);
+        if (errors2.First()) {
+          for (const error of errors2) {
+            this._logger.warn("Configuration validation error", { err: error });
+          }
+        }
+        const decodedConfig = import_value.Value.Decode(configSchema, configSchemaWithDefaults);
+        return { config: decodedConfig, errors: errors2, rawData };
+      } catch (error) {
+        this._logger.error("Error decoding configuration; Will ignore.", { err: error, owner, repository });
+        return { config: null, errors: [error instanceof import_value.TransformDecodeCheckError ? error.error : error], rawData };
+      }
+    }
+    this._logger.error("YAML could not be decoded", { owner, repository, errors });
+    return { config: null, errors, rawData };
+  }
+  async _download({ repository, owner }) {
+    if (!repository || !owner) {
+      this._logger.error("Repo or owner is not defined, cannot download the requested file");
+      return null;
+    }
+    const pathList = [CONFIG_PROD_FULL_PATH, CONFIG_DEV_FULL_PATH];
+    for (const filePath of pathList) {
+      try {
+        this._logger.debug("Attempting to fetch configuration", { owner, repository, filePath });
+        const { data, headers } = await this._octokit.rest.repos.getContent({
+          owner,
+          repo: repository,
+          path: filePath,
+          mediaType: { format: "raw" }
+        });
+        this._logger.debug("Configuration file found", { owner, repository, filePath, rateLimitRemaining: headers?.["x-ratelimit-remaining"], data });
+        return data;
+      } catch (err) {
+        if (err && typeof err === "object" && "status" in err && err.status === 404) {
+          this._logger.warn("No configuration file found", { owner, repository, filePath });
+        } else {
+          this._logger.error("Failed to download the requested file", { err, owner, repository, filePath });
+        }
+      }
+    }
+    return null;
+  }
+  _parseYaml(data) {
+    this._logger.debug("Will attempt to parse YAML data", { data });
+    try {
+      if (data) {
+        const parsedData = import_js_yaml.default.load(data);
+        this._logger.debug("Parsed yaml data", { parsedData });
+        return { yaml: parsedData ?? null, errors: null };
+      }
+    } catch (error) {
+      this._logger.error("Error parsing YAML", { error });
+      return { errors: [error], yaml: null };
+    }
+    this._logger.debug("Could not parse YAML");
+    return { yaml: null, errors: null };
+  }
+  mergeConfigurations(configuration1, configuration2) {
+    const mergedPlugins = {
+      ...configuration1.plugins,
+      ...configuration2.plugins
+    };
+    return {
+      ...configuration1,
+      ...configuration2,
+      plugins: mergedPlugins
+    };
+  }
+  getManifest(plugin) {
+    return this._fetchActionManifest(plugin);
+  }
+  async _fetchActionManifest({ owner, repo, ref }) {
+    const manifestKey = ref ? `${owner}:${repo}:${ref}` : `${owner}:${repo}`;
+    if (this._manifestCache[manifestKey]) {
+      return this._manifestCache[manifestKey];
+    }
+    if (this._manifestPromiseCache[manifestKey]) {
+      return this._manifestPromiseCache[manifestKey];
+    }
+    const manifestPromise = (async () => {
+      try {
+        const { data } = await this._octokit.rest.repos.getContent({
+          owner,
+          repo,
+          path: "manifest.json",
+          ref
+        });
+        if ("content" in data) {
+          const content = import_node_buffer.Buffer.from(data.content, "base64").toString();
+          const contentParsed = JSON.parse(content);
+          const manifest = this._decodeManifest(contentParsed);
+          this._manifestCache[manifestKey] = manifest;
+          return manifest;
+        }
+      } catch (e) {
+        this._logger.error("Could not find a valid manifest", { owner, repo, err: e });
+      }
+      return null;
+    })();
+    this._manifestPromiseCache[manifestKey] = manifestPromise;
+    try {
+      return await manifestPromise;
+    } finally {
+      delete this._manifestPromiseCache[manifestKey];
+    }
+  }
+  _decodeManifest(manifest) {
+    const errors = [...import_value.Value.Errors(manifestSchema, manifest)];
+    if (errors.length) {
+      for (const error of errors) {
+        this._logger.error("Manifest validation error", { error });
+      }
+      throw new Error("Manifest is invalid.");
+    }
+    const defaultManifest = import_value.Value.Default(manifestSchema, manifest);
+    return defaultManifest;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_DEV_FULL_PATH,
+  CONFIG_ORG_REPO,
+  CONFIG_PROD_FULL_PATH,
+  ConfigurationHandler
+});

package/dist/configuration.mjs

@@ -0,0 +1,302 @@
+// src/configuration.ts
+import { TransformDecodeCheckError, Value } from "@sinclair/typebox/value";
+import YAML from "js-yaml";
+import { Buffer } from "node:buffer";
+
+// src/configuration/schema.ts
+import { emitterEventNames } from "@octokit/webhooks";
+import { Type as T } from "@sinclair/typebox";
+var pluginNameRegex = new RegExp("^([0-9a-zA-Z-._]+)\\/([0-9a-zA-Z-._]+)(?::([0-9a-zA-Z-._]+))?(?:@([0-9a-zA-Z-._]+(?:\\/[0-9a-zA-Z-._]+)*))?$");
+function parsePluginIdentifier(value) {
+  const matches = pluginNameRegex.exec(value);
+  if (!matches) {
+    throw new Error(`Invalid plugin name: ${value}`);
+  }
+  return {
+    owner: matches[1],
+    repo: matches[2],
+    workflowId: matches[3] || "compute.yml",
+    ref: matches[4] || void 0
+  };
+}
+function stringLiteralUnion(values) {
+  const literals = values.map((value) => T.Literal(value));
+  return T.Union(literals);
+}
+var emitterType = stringLiteralUnion(emitterEventNames);
+var runsOnSchema = T.Array(emitterType, { default: [] });
+var pluginSettingsSchema = T.Union(
+  [
+    T.Null(),
+    T.Object(
+      {
+        with: T.Record(T.String(), T.Unknown(), { default: {} }),
+        runsOn: T.Optional(runsOnSchema),
+        skipBotEvents: T.Optional(T.Boolean())
+      },
+      { default: {} }
+    )
+  ],
+  { default: null }
+);
+var configSchema = T.Object(
+  {
+    plugins: T.Record(T.String(), pluginSettingsSchema, { default: {} })
+  },
+  {
+    additionalProperties: true
+  }
+);
+
+// src/types/manifest.ts
+import { Type as T2 } from "@sinclair/typebox";
+import { emitterEventNames as emitterEventNames2 } from "@octokit/webhooks";
+var runEvent = T2.Union(emitterEventNames2.map((o) => T2.Literal(o)));
+var exampleCommandExecutionSchema = T2.Object({
+  commandInvocation: T2.String({ minLength: 1 }),
+  githubContext: T2.Optional(T2.Record(T2.String(), T2.Any())),
+  expectedToolCallResult: T2.Object({
+    function: T2.String({ minLength: 1 }),
+    parameters: T2.Record(T2.String(), T2.Any())
+  })
+});
+var commandSchema = T2.Object({
+  description: T2.String({ minLength: 1 }),
+  "ubiquity:example": T2.String({ minLength: 1 }),
+  parameters: T2.Optional(T2.Record(T2.String(), T2.Any())),
+  examples: T2.Optional(T2.Array(exampleCommandExecutionSchema, { default: [] }))
+});
+var manifestSchema = T2.Object({
+  name: T2.String({ minLength: 1 }),
+  short_name: T2.String({ minLength: 1 }),
+  description: T2.Optional(T2.String({ default: "" })),
+  commands: T2.Optional(T2.Record(T2.String({ pattern: "^[A-Za-z-_]+$" }), commandSchema, { default: {} })),
+  "ubiquity:listeners": T2.Optional(T2.Array(runEvent, { default: [] })),
+  configuration: T2.Optional(T2.Record(T2.String(), T2.Any(), { default: {} })),
+  skipBotEvents: T2.Optional(T2.Boolean({ default: true }))
+});
+
+// src/configuration.ts
+var CONFIG_PROD_FULL_PATH = ".github/.ubiquity-os.config.yml";
+var CONFIG_DEV_FULL_PATH = ".github/.ubiquity-os.config.dev.yml";
+var CONFIG_ORG_REPO = ".ubiquity-os";
+var ConfigurationHandler = class {
+  constructor(_logger, _octokit) {
+    this._logger = _logger;
+    this._octokit = _octokit;
+  }
+  _manifestCache = {};
+  _manifestPromiseCache = {};
+  /**
+   *  Retrieves the configuration for the current plugin based on its manifest.
+   *  @param manifest - The plugin manifest containing the `short_name` identifier
+   *  @param location - Optional repository location (`owner/repo`)
+   *  @returns The plugin's configuration or null if not found
+   **/
+  async getSelfConfiguration(manifest, location) {
+    const cfg = await this.getConfiguration(location);
+    const name = manifest.short_name.split("@")[0];
+    const selfConfig = Object.keys(cfg.plugins).find((key) => new RegExp(`^${name}(?:$|@.+)`).exec(key.replace(/:[^@]+/, "")));
+    return selfConfig && cfg.plugins[selfConfig] ? cfg.plugins[selfConfig]["with"] : null;
+  }
+  /**
+   * Retrieves and merges configuration from organization and repository levels.
+   * @param location - Optional repository location (`owner` and `repo`). If not provided, returns the default configuration.
+   * @returns The merged plugin configuration with resolved plugin settings.
+   */
+  async getConfiguration(location) {
+    const defaultConfiguration = Value.Decode(configSchema, Value.Default(configSchema, {}));
+    if (!location) {
+      this._logger.debug("No location was provided, using the default configuration");
+      return defaultConfiguration;
+    }
+    const { owner, repo } = location;
+    let mergedConfiguration = defaultConfiguration;
+    this._logger.debug("Fetching configurations from the organization and repository", {
+      orgRepo: `${owner}/${CONFIG_ORG_REPO}`,
+      repo: `${owner}/${repo}`
+    });
+    const orgConfig = await this._getConfigurationFromRepo(owner, CONFIG_ORG_REPO);
+    const repoConfig = await this._getConfigurationFromRepo(owner, repo);
+    if (orgConfig.config) {
+      mergedConfiguration = this.mergeConfigurations(mergedConfiguration, orgConfig.config);
+    }
+    if (repoConfig.config) {
+      mergedConfiguration = this.mergeConfigurations(mergedConfiguration, repoConfig.config);
+    }
+    const resolvedPlugins = {};
+    this._logger.debug("Found plugins enabled", { repo: `${owner}/${repo}`, plugins: Object.keys(mergedConfiguration.plugins).length });
+    for (const [pluginKey, pluginSettings] of Object.entries(mergedConfiguration.plugins)) {
+      let pluginIdentifier;
+      try {
+        pluginIdentifier = parsePluginIdentifier(pluginKey);
+      } catch (error) {
+        this._logger.error("Invalid plugin identifier; skipping", { plugin: pluginKey, err: error });
+        continue;
+      }
+      const manifest = await this.getManifest(pluginIdentifier);
+      let runsOn = pluginSettings?.runsOn ?? [];
+      let shouldSkipBotEvents = pluginSettings?.skipBotEvents;
+      if (manifest) {
+        if (!runsOn.length) {
+          runsOn = manifest["ubiquity:listeners"] ?? [];
+        }
+        if (shouldSkipBotEvents === void 0) {
+          shouldSkipBotEvents = manifest.skipBotEvents ?? true;
+        }
+      } else {
+        shouldSkipBotEvents = true;
+      }
+      resolvedPlugins[pluginKey] = {
+        ...pluginSettings,
+        with: pluginSettings?.with ?? {},
+        runsOn,
+        skipBotEvents: shouldSkipBotEvents
+      };
+    }
+    return {
+      ...mergedConfiguration,
+      plugins: resolvedPlugins
+    };
+  }
+  async _getConfigurationFromRepo(owner, repository) {
+    const rawData = await this._download({
+      repository,
+      owner
+    });
+    this._logger.debug("Downloaded configuration file", { owner, repository });
+    if (!rawData) {
+      this._logger.debug("No raw configuration data", { owner, repository });
+      return { config: null, errors: null, rawData: null };
+    }
+    const { yaml, errors } = this._parseYaml(rawData);
+    const targetRepoConfiguration = yaml;
+    this._logger.debug("Decoding configuration", { owner, repository });
+    if (targetRepoConfiguration) {
+      try {
+        const configSchemaWithDefaults = Value.Default(configSchema, targetRepoConfiguration);
+        const errors2 = Value.Errors(configSchema, configSchemaWithDefaults);
+        if (errors2.First()) {
+          for (const error of errors2) {
+            this._logger.warn("Configuration validation error", { err: error });
+          }
+        }
+        const decodedConfig = Value.Decode(configSchema, configSchemaWithDefaults);
+        return { config: decodedConfig, errors: errors2, rawData };
+      } catch (error) {
+        this._logger.error("Error decoding configuration; Will ignore.", { err: error, owner, repository });
+        return { config: null, errors: [error instanceof TransformDecodeCheckError ? error.error : error], rawData };
+      }
+    }
+    this._logger.error("YAML could not be decoded", { owner, repository, errors });
+    return { config: null, errors, rawData };
+  }
+  async _download({ repository, owner }) {
+    if (!repository || !owner) {
+      this._logger.error("Repo or owner is not defined, cannot download the requested file");
+      return null;
+    }
+    const pathList = [CONFIG_PROD_FULL_PATH, CONFIG_DEV_FULL_PATH];
+    for (const filePath of pathList) {
+      try {
+        this._logger.debug("Attempting to fetch configuration", { owner, repository, filePath });
+        const { data, headers } = await this._octokit.rest.repos.getContent({
+          owner,
+          repo: repository,
+          path: filePath,
+          mediaType: { format: "raw" }
+        });
+        this._logger.debug("Configuration file found", { owner, repository, filePath, rateLimitRemaining: headers?.["x-ratelimit-remaining"], data });
+        return data;
+      } catch (err) {
+        if (err && typeof err === "object" && "status" in err && err.status === 404) {
+          this._logger.warn("No configuration file found", { owner, repository, filePath });
+        } else {
+          this._logger.error("Failed to download the requested file", { err, owner, repository, filePath });
+        }
+      }
+    }
+    return null;
+  }
+  _parseYaml(data) {
+    this._logger.debug("Will attempt to parse YAML data", { data });
+    try {
+      if (data) {
+        const parsedData = YAML.load(data);
+        this._logger.debug("Parsed yaml data", { parsedData });
+        return { yaml: parsedData ?? null, errors: null };
+      }
+    } catch (error) {
+      this._logger.error("Error parsing YAML", { error });
+      return { errors: [error], yaml: null };
+    }
+    this._logger.debug("Could not parse YAML");
+    return { yaml: null, errors: null };
+  }
+  mergeConfigurations(configuration1, configuration2) {
+    const mergedPlugins = {
+      ...configuration1.plugins,
+      ...configuration2.plugins
+    };
+    return {
+      ...configuration1,
+      ...configuration2,
+      plugins: mergedPlugins
+    };
+  }
+  getManifest(plugin) {
+    return this._fetchActionManifest(plugin);
+  }
+  async _fetchActionManifest({ owner, repo, ref }) {
+    const manifestKey = ref ? `${owner}:${repo}:${ref}` : `${owner}:${repo}`;
+    if (this._manifestCache[manifestKey]) {
+      return this._manifestCache[manifestKey];
+    }
+    if (this._manifestPromiseCache[manifestKey]) {
+      return this._manifestPromiseCache[manifestKey];
+    }
+    const manifestPromise = (async () => {
+      try {
+        const { data } = await this._octokit.rest.repos.getContent({
+          owner,
+          repo,
+          path: "manifest.json",
+          ref
+        });
+        if ("content" in data) {
+          const content = Buffer.from(data.content, "base64").toString();
+          const contentParsed = JSON.parse(content);
+          const manifest = this._decodeManifest(contentParsed);
+          this._manifestCache[manifestKey] = manifest;
+          return manifest;
+        }
+      } catch (e) {
+        this._logger.error("Could not find a valid manifest", { owner, repo, err: e });
+      }
+      return null;
+    })();
+    this._manifestPromiseCache[manifestKey] = manifestPromise;
+    try {
+      return await manifestPromise;
+    } finally {
+      delete this._manifestPromiseCache[manifestKey];
+    }
+  }
+  _decodeManifest(manifest) {
+    const errors = [...Value.Errors(manifestSchema, manifest)];
+    if (errors.length) {
+      for (const error of errors) {
+        this._logger.error("Manifest validation error", { error });
+      }
+      throw new Error("Manifest is invalid.");
+    }
+    const defaultManifest = Value.Default(manifestSchema, manifest);
+    return defaultManifest;
+  }
+};
+export {
+  CONFIG_DEV_FULL_PATH,
+  CONFIG_ORG_REPO,
+  CONFIG_PROD_FULL_PATH,
+  ConfigurationHandler
+};