@ubiquity-os/plugin-sdk 3.6.3 → 3.7.0

package/dist/configuration.mjs

@@ -2707,14 +2707,101 @@ var manifestSchema = T2.Object({
 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 ENVIRONMENT_TO_CONFIG_SUFFIX = {
+  development: "dev"
+};
+var VALID_CONFIG_SUFFIX = /^[a-z0-9][a-z0-9_-]*$/i;
+var MAX_IMPORT_DEPTH = 6;
+function normalizeEnvironmentName(environment) {
+  return String(environment ?? "").trim().toLowerCase();
+}
+function getConfigPathCandidatesForEnvironment(environment) {
+  const normalized = normalizeEnvironmentName(environment);
+  if (!normalized) {
+    return [CONFIG_PROD_FULL_PATH, CONFIG_DEV_FULL_PATH];
+  }
+  if (normalized === "production" || normalized === "prod") {
+    return [CONFIG_PROD_FULL_PATH];
+  }
+  const suffix = ENVIRONMENT_TO_CONFIG_SUFFIX[normalized] ?? normalized;
+  if (suffix === "dev") {
+    return [CONFIG_DEV_FULL_PATH];
+  }
+  if (!VALID_CONFIG_SUFFIX.test(suffix)) {
+    return [CONFIG_DEV_FULL_PATH];
+  }
+  return [`.github/.ubiquity-os.config.${suffix}.yml`, CONFIG_PROD_FULL_PATH];
+}
+function normalizeImportKey(location) {
+  return `${location.owner}`.trim().toLowerCase() + "/" + `${location.repo}`.trim().toLowerCase();
+}
+function parseImportSpec(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split("/");
+  if (parts.length !== 2) return null;
+  const [owner, repo] = parts;
+  if (!owner || !repo) return null;
+  return { owner, repo };
+}
+function readImports(logger, value, source) {
+  if (!value) return [];
+  if (!Array.isArray(value)) {
+    logger.warn("Invalid imports; expected a list of strings.", { source });
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const imports = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      logger.warn("Ignoring invalid import entry; expected string.", { source, entry });
+      continue;
+    }
+    const parsed = parseImportSpec(entry);
+    if (!parsed) {
+      logger.warn("Ignoring invalid import entry; expected owner/repo.", { source, entry });
+      continue;
+    }
+    const key = normalizeImportKey(parsed);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    imports.push(parsed);
+  }
+  return imports;
+}
+function stripImports(config) {
+  if (!config || typeof config !== "object") return config;
+  const { imports: _imports, ...rest } = config;
+  return rest;
+}
+function mergeImportedConfigs(imported, base) {
+  if (!imported.length) {
+    return base;
+  }
+  let merged = imported[0];
+  for (let i = 1; i < imported.length; i++) {
+    merged = {
+      ...merged,
+      ...imported[i],
+      plugins: { ...merged.plugins, ...imported[i].plugins }
+    };
+  }
+  return base ? {
+    ...merged,
+    ...base,
+    plugins: { ...merged.plugins, ...base.plugins }
+  } : merged;
+}
 var ConfigurationHandler = class {
-  constructor(_logger, _octokit, _environment = null) {
+  constructor(_logger, _octokit, _environment = null, options) {
     this._logger = _logger;
     this._octokit = _octokit;
     this._environment = _environment;
+    this._octokitFactory = options?.octokitFactory;
   }
   _manifestCache = {};
   _manifestPromiseCache = {};
+  _octokitFactory;
   /**
    *  Retrieves the configuration for the current plugin based on its manifest.
    *  @param manifest - The plugin manifest containing the `short_name` identifier
@@ -2733,7 +2820,7 @@ var ConfigurationHandler = class {
    * @returns The merged plugin configuration with resolved plugin settings.
    */
   async getConfiguration(location) {
-    const defaultConfiguration = Value.Decode(configSchema, Value.Default(configSchema, {}));
+    const defaultConfiguration = stripImports(Value.Decode(configSchema, Value.Default(configSchema, {})));
     if (!location) {
       this._logger.info("No location was provided, using the default configuration");
       return defaultConfiguration;
@@ -2794,57 +2881,153 @@ var ConfigurationHandler = class {
    * @param repository The repository name
    */
   async getConfigurationFromRepo(owner, repository) {
+    const location = { owner, repo: repository };
+    const state = this._createImportState();
+    const octokit = await this._getOctokitForLocation(location, state);
+    if (!octokit) {
+      this._logger.warn("No Octokit available for configuration load", { owner, repository });
+      return { config: null, errors: null, rawData: null };
+    }
+    const { config, imports, errors, rawData } = await this._loadConfigSource(location, octokit);
+    if (!rawData) {
+      return { config: null, errors: null, rawData: null };
+    }
+    if (errors && errors.length) {
+      this._logger.warn("YAML could not be decoded", { owner, repository, errors });
+      return { config: null, errors, rawData };
+    }
+    if (!config) {
+      this._logger.warn("YAML could not be decoded", { owner, repository });
+      return { config: null, errors, rawData };
+    }
+    const importedConfigs = [];
+    for (const next of imports) {
+      const resolved = await this._resolveImportedConfiguration(next, state, 1);
+      if (resolved) importedConfigs.push(resolved);
+    }
+    const mergedConfig = mergeImportedConfigs(importedConfigs, config);
+    if (!mergedConfig) {
+      return { config: null, errors: null, rawData };
+    }
+    const decoded = this._decodeConfiguration(location, mergedConfig);
+    return { config: decoded.config, errors: decoded.errors, rawData };
+  }
+  _createImportState() {
+    return {
+      cache: /* @__PURE__ */ new Map(),
+      inFlight: /* @__PURE__ */ new Set(),
+      octokitByLocation: /* @__PURE__ */ new Map()
+    };
+  }
+  async _getOctokitForLocation(location, state) {
+    const key = normalizeImportKey(location);
+    if (state.octokitByLocation.has(key)) {
+      return state.octokitByLocation.get(key) ?? null;
+    }
+    if (this._octokitFactory) {
+      const resolved = await this._octokitFactory(location);
+      if (resolved) {
+        state.octokitByLocation.set(key, resolved);
+        return resolved;
+      }
+    }
+    state.octokitByLocation.set(key, this._octokit);
+    return this._octokit;
+  }
+  async _loadConfigSource(location, octokit) {
     const rawData = await this._download({
-      repository,
-      owner
+      repository: location.repo,
+      owner: location.owner,
+      octokit
     });
-    this._logger.ok("Downloaded configuration file", { owner, repository });
+    this._logger.ok("Downloaded configuration file", { owner: location.owner, repository: location.repo });
     if (!rawData) {
-      this._logger.warn("No raw configuration data", { owner, repository });
-      return { config: null, errors: null, rawData: null };
+      this._logger.warn("No raw configuration data", { owner: location.owner, repository: location.repo });
+      return { config: null, imports: [], errors: null, rawData: null };
     }
     const { yaml, errors } = this._parseYaml(rawData);
+    const imports = readImports(this._logger, yaml?.imports, location);
+    if (yaml && typeof yaml === "object" && !Array.isArray(yaml) && "imports" in yaml) {
+      delete yaml.imports;
+    }
     const targetRepoConfiguration = yaml;
-    this._logger.info("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 });
-          }
+    return { config: targetRepoConfiguration, imports, errors, rawData };
+  }
+  _decodeConfiguration(location, config) {
+    this._logger.info("Decoding configuration", { owner: location.owner, repository: location.repo });
+    try {
+      const configSchemaWithDefaults = Value.Default(configSchema, config);
+      const errors = Value.Errors(configSchema, configSchemaWithDefaults);
+      if (errors.First()) {
+        for (const error of errors) {
+          this._logger.warn("Configuration validation error", { err: error });
         }
-        const decodedConfig = Value.Decode(configSchema, configSchemaWithDefaults);
-        return { config: decodedConfig, errors: errors2.First() ? errors2 : null, rawData };
-      } catch (error) {
-        this._logger.warn("Error decoding configuration; Will ignore.", { err: error, owner, repository });
-        return { config: null, errors: [error instanceof TransformDecodeCheckError ? error.error : error], rawData };
       }
+      const decodedConfig = Value.Decode(configSchema, configSchemaWithDefaults);
+      return { config: stripImports(decodedConfig), errors: errors.First() ? errors : null };
+    } catch (error) {
+      this._logger.warn("Error decoding configuration; Will ignore.", { err: error, owner: location.owner, repository: location.repo });
+      return { config: null, errors: [error instanceof TransformDecodeCheckError ? error.error : error] };
     }
-    this._logger.warn("YAML could not be decoded", { owner, repository, errors });
-    return { config: null, errors, rawData };
   }
-  async _download({ repository, owner }) {
+  async _resolveImportedConfiguration(location, state, depth) {
+    const key = normalizeImportKey(location);
+    if (state.cache.has(key)) {
+      return state.cache.get(key) ?? null;
+    }
+    if (state.inFlight.has(key)) {
+      this._logger.warn("Skipping import due to circular reference.", { location });
+      return null;
+    }
+    if (depth > MAX_IMPORT_DEPTH) {
+      this._logger.warn("Skipping import; maximum depth exceeded.", { location, depth });
+      return null;
+    }
+    state.inFlight.add(key);
+    let resolved = null;
+    try {
+      const octokit = await this._getOctokitForLocation(location, state);
+      if (!octokit) {
+        this._logger.warn("Skipping import; no authorized Octokit for owner.", { location });
+        return null;
+      }
+      const { config, imports, errors } = await this._loadConfigSource(location, octokit);
+      if (errors && errors.length) {
+        this._logger.warn("Skipping import due to YAML parsing errors.", { location, errors });
+        return null;
+      }
+      if (!config) {
+        return null;
+      }
+      const importedConfigs = [];
+      for (const next of imports) {
+        const nested = await this._resolveImportedConfiguration(next, state, depth + 1);
+        if (nested) importedConfigs.push(nested);
+      }
+      const mergedConfig = mergeImportedConfigs(importedConfigs, config);
+      if (!mergedConfig) return null;
+      const decoded = this._decodeConfiguration(location, mergedConfig);
+      resolved = decoded.config;
+    } finally {
+      state.inFlight.delete(key);
+      state.cache.set(key, resolved);
+    }
+    return resolved;
+  }
+  async _download({
+    repository,
+    owner,
+    octokit
+  }) {
     if (!repository || !owner) {
       this._logger.warn("Repo or owner is not defined, cannot download the requested file");
       return null;
     }
-    let pathList;
-    switch (this._environment) {
-      case "development":
-        pathList = [CONFIG_DEV_FULL_PATH];
-        break;
-      case "production":
-        pathList = [CONFIG_PROD_FULL_PATH];
-        break;
-      default:
-        pathList = [CONFIG_PROD_FULL_PATH, CONFIG_DEV_FULL_PATH];
-    }
+    const pathList = getConfigPathCandidatesForEnvironment(this._environment);
     for (const filePath of pathList) {
       try {
         this._logger.info("Attempting to fetch configuration", { owner, repository, filePath });
-        const { data, headers } = await this._octokit.rest.repos.getContent({
+        const { data, headers } = await octokit.rest.repos.getContent({
           owner,
           repo: repository,
           path: filePath,

package/dist/{context-BbEmsEct.d.ts → context-BE4WjJZf.d.ts}

@@ -45,6 +45,7 @@ declare class CommentHandler {
     _extractIssueContext(context: Context): IssueContext | null;
     _processMessage(context: Context, message: LogReturn | Error): {
         metadata: {
+            status?: number | undefined;
             message: string;
             name: string;
             stack: string | undefined;

package/dist/{context-sqbr2o6i.d.mts → context-Ckj1HMjz.d.mts}

@@ -45,6 +45,7 @@ declare class CommentHandler {
     _extractIssueContext(context: Context): IssueContext | null;
     _processMessage(context: Context, message: LogReturn | Error): {
         metadata: {
+            status?: number | undefined;
             message: string;
             name: string;
             stack: string | undefined;

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { EmitterWebhookEventName } from '@octokit/webhooks';
-import { C as Context } from './context-sqbr2o6i.mjs';
-export { a as CommentHandler } from './context-sqbr2o6i.mjs';
+import { C as Context } from './context-Ckj1HMjz.mjs';
+export { a as CommentHandler } from './context-Ckj1HMjz.mjs';
 import { TSchema, TAnySchema } from '@sinclair/typebox';
 import { LogLevel } from '@ubiquity-os/ubiquity-os-logger';
 import * as hono_types from 'hono/types';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { EmitterWebhookEventName } from '@octokit/webhooks';
-import { C as Context } from './context-BbEmsEct.js';
-export { a as CommentHandler } from './context-BbEmsEct.js';
+import { C as Context } from './context-BE4WjJZf.js';
+export { a as CommentHandler } from './context-BE4WjJZf.js';
 import { TSchema, TAnySchema } from '@sinclair/typebox';
 import { LogLevel } from '@ubiquity-os/ubiquity-os-logger';
 import * as hono_types from 'hono/types';