@ubiquity-os/plugin-sdk 3.6.2 → 3.7.0

package/dist/configuration.js

@@ -502,7 +502,7 @@ var int = new type("tag:yaml.org,2002:int", {
     decimal: function(obj) {
       return obj.toString(10);
     },
-     
+    /* eslint-disable max-len */
     hexadecimal: function(obj) {
       return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
     }
@@ -2693,6 +2693,7 @@ var pluginSettingsSchema = import_typebox.Type.Union(
 );
 var configSchema = import_typebox.Type.Object(
   {
+    imports: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { default: [] })),
     plugins: import_typebox.Type.Record(import_typebox.Type.String(), pluginSettingsSchema, { default: {} })
   },
   {
@@ -2733,14 +2734,101 @@ var manifestSchema = import_typebox2.Type.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
@@ -2759,14 +2847,14 @@ var ConfigurationHandler = class {
    * @returns The merged plugin configuration with resolved plugin settings.
    */
   async getConfiguration(location) {
-    const defaultConfiguration = import_value.Value.Decode(configSchema, import_value.Value.Default(configSchema, {}));
+    const defaultConfiguration = stripImports(import_value.Value.Decode(configSchema, import_value.Value.Default(configSchema, {})));
     if (!location) {
-      this._logger.debug("No location was provided, using the default configuration");
+      this._logger.info("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", {
+    this._logger.info("Fetching configurations from the organization and repository", {
       orgRepo: `${owner}/${CONFIG_ORG_REPO}`,
       repo: `${owner}/${repo}`
     });
@@ -2779,13 +2867,13 @@ var ConfigurationHandler = class {
       mergedConfiguration = this.mergeConfigurations(mergedConfiguration, repoConfig.config);
     }
     const resolvedPlugins = {};
-    this._logger.debug("Found plugins enabled", { repo: `${owner}/${repo}`, plugins: Object.keys(mergedConfiguration.plugins).length });
+    this._logger.ok("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 });
+        this._logger.warn("Invalid plugin identifier; skipping", { plugin: pluginKey, err: error });
         continue;
       }
       const manifest = await this.getManifest(pluginIdentifier);
@@ -2820,87 +2908,189 @@ 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.debug("Downloaded configuration file", { owner, repository });
+    this._logger.ok("Downloaded configuration file", { owner: location.owner, repository: location.repo });
     if (!rawData) {
-      this._logger.debug("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.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 });
-          }
+    return { config: targetRepoConfiguration, imports, errors, rawData };
+  }
+  _decodeConfiguration(location, config) {
+    this._logger.info("Decoding configuration", { owner: location.owner, repository: location.repo });
+    try {
+      const configSchemaWithDefaults = import_value.Value.Default(configSchema, config);
+      const errors = import_value.Value.Errors(configSchema, configSchemaWithDefaults);
+      if (errors.First()) {
+        for (const error of errors) {
+          this._logger.warn("Configuration validation error", { err: error });
         }
-        const decodedConfig = import_value.Value.Decode(configSchema, configSchemaWithDefaults);
-        return { config: decodedConfig, errors: errors2.First() ? errors2 : null, 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 };
       }
+      const decodedConfig = import_value.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 import_value.TransformDecodeCheckError ? error.error : error] };
     }
-    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");
+  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;
     }
-    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];
+    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;
+    }
+    const pathList = getConfigPathCandidatesForEnvironment(this._environment);
     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({
+        this._logger.info("Attempting to fetch configuration", { owner, repository, filePath });
+        const { data, headers } = await 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 });
+        this._logger.ok("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 });
+          const status = err && typeof err === "object" && "status" in err ? Number(err.status) : null;
+          const metadata = { err, owner, repository, filePath, ...status ? { status } : {} };
+          if (status && status >= 500) {
+            this._logger.error("Failed to download the requested file", metadata);
+          } else {
+            this._logger.warn("Failed to download the requested file", metadata);
+          }
         }
       }
     }
     return null;
   }
   _parseYaml(data) {
-    this._logger.debug("Will attempt to parse YAML data", { data });
+    this._logger.info("Will attempt to parse YAML data", { data });
     try {
       if (data) {
         const parsedData = jsYaml.load(data);
-        this._logger.debug("Parsed yaml data", { parsedData });
+        this._logger.ok("Parsed yaml data", { parsedData });
         return { yaml: parsedData ?? null, errors: null };
       }
     } catch (error) {
-      this._logger.error("Error parsing YAML", { error });
+      this._logger.warn("Error parsing YAML", { error });
       return { errors: [error], yaml: null };
     }
-    this._logger.debug("Could not parse YAML");
+    this._logger.warn("Could not parse YAML");
     return { yaml: null, errors: null };
   }
   mergeConfigurations(configuration1, configuration2) {
@@ -2941,7 +3131,7 @@ var ConfigurationHandler = class {
           return manifest;
         }
       } catch (e) {
-        this._logger.error("Could not find a valid manifest", { owner, repo, err: e });
+        this._logger.warn("Could not find a valid manifest", { owner, repo, err: e });
       }
       return null;
     })();
@@ -2956,7 +3146,7 @@ var ConfigurationHandler = class {
     const errors = [...import_value.Value.Errors(manifestSchema, manifest)];
     if (errors.length) {
       for (const error of errors) {
-        this._logger.error("Manifest validation error", { error });
+        this._logger.warn("Manifest validation error", { error });
       }
       throw new Error("Manifest is invalid.");
     }