@kitsy/cnos 0.0.1 → 1.0.0

package/dist/chunk-I6QXNQEF.js

@@ -0,0 +1,202 @@
+import {
+  CnosManifestError,
+  isSecretReference,
+  parseYaml,
+  readLocalSecret,
+  resolveSecretStoreRoot,
+  toPortablePath
+} from "./chunk-D7AYK7X5.js";
+
+// ../../plugins/filesystem/src/helpers.ts
+import { readdir } from "fs/promises";
+import path from "path";
+var YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yml", ".yaml"]);
+var FILESYSTEM_PLUGIN_ID = "@kitsy/cnos/plugins/filesystem";
+async function existsDirectory(targetPath) {
+  try {
+    const stat = await readdir(targetPath);
+    void stat;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectYamlFiles(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const absolutePath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await collectYamlFiles(absolutePath));
+      continue;
+    }
+    if (entry.isFile() && YAML_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+      results.push(absolutePath);
+    }
+  }
+  return results;
+}
+async function collectFilesystemLayerFiles(manifestRoot, workspaceRoots, sourceRoot, activeLayers) {
+  const files = [];
+  const repoRoot = path.dirname(manifestRoot);
+  for (const workspaceRoot of workspaceRoots) {
+    const resolvedRoot = path.resolve(workspaceRoot.path, sourceRoot);
+    for (const layer of activeLayers) {
+      const layerRoot = path.join(resolvedRoot, layer);
+      if (!await existsDirectory(layerRoot)) {
+        continue;
+      }
+      for (const absolutePath of await collectYamlFiles(layerRoot)) {
+        const relativePath = path.relative(repoRoot, absolutePath);
+        files.push({
+          absolutePath,
+          relativePath: toPortablePath(relativePath.startsWith("..") ? absolutePath : relativePath),
+          workspaceId: workspaceRoot.workspaceId
+        });
+      }
+    }
+  }
+  return files;
+}
+function assertObjectDocument(value, filePath) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new CnosManifestError("Filesystem loader expected a YAML object document", filePath);
+  }
+  return value;
+}
+function flattenConfigObject(value, options = {}, prefix = "") {
+  return Object.entries(value).reduce((accumulator, [key, nestedValue]) => {
+    const nextKey = prefix ? `${prefix}.${key}` : key;
+    if (nestedValue && typeof nestedValue === "object" && !Array.isArray(nestedValue) && !options.stopAtLeaf?.(nestedValue)) {
+      Object.assign(
+        accumulator,
+        flattenConfigObject(nestedValue, options, nextKey)
+      );
+      return accumulator;
+    }
+    accumulator[nextKey] = nestedValue;
+    return accumulator;
+  }, {});
+}
+function yamlObjectToEntries(document, filePath, namespace, sourceId, workspaceId = "default") {
+  const parsed = assertObjectDocument(parseYaml(document), filePath);
+  const flattened = flattenConfigObject(parsed, {
+    ...namespace === "secret" ? {
+      stopAtLeaf: isSecretReference
+    } : {}
+  });
+  return Object.entries(flattened).map(([key, value]) => ({
+    key: `${namespace}.${key}`,
+    value,
+    namespace,
+    sourceId,
+    pluginId: FILESYSTEM_PLUGIN_ID,
+    workspaceId,
+    origin: {
+      file: filePath
+    }
+  }));
+}
+async function resolveSecretValue(value, processEnv) {
+  if (!isSecretReference(value)) {
+    return value;
+  }
+  if (value.provider === "local") {
+    if (!processEnv?.CNOS_SECRET_PASSPHRASE) {
+      return value;
+    }
+    return readLocalSecret(
+      resolveSecretStoreRoot(processEnv),
+      value.ref,
+      processEnv?.CNOS_SECRET_PASSPHRASE
+    );
+  }
+  if (value.provider === "env") {
+    const resolved = processEnv?.[value.ref];
+    if (resolved === void 0) {
+      return value;
+    }
+    return resolved;
+  }
+  return value;
+}
+function toSecretReferenceMetadata(value) {
+  if (!isSecretReference(value)) {
+    return void 0;
+  }
+  return {
+    secretRef: value
+  };
+}
+
+// ../../plugins/filesystem/src/filesystemSecretsReader.ts
+import { readFile } from "fs/promises";
+function filesystemSecretsReader(filePath, document, workspaceId = "default") {
+  return yamlObjectToEntries(document, filePath, "secret", "filesystem-secrets", workspaceId);
+}
+function createFilesystemSecretsPlugin() {
+  return {
+    id: "filesystem-secrets",
+    kind: "loader",
+    async load(context) {
+      const sourceRoot = String(context.manifestConfig.root ?? "./");
+      const files = await collectFilesystemLayerFiles(
+        context.manifestRoot,
+        context.workspace.workspaceRoots,
+        sourceRoot,
+        context.profileActivation.secrets
+      );
+      const entries = [];
+      for (const file of files) {
+        const document = await readFile(file.absolutePath, "utf8");
+        const fileEntries = filesystemSecretsReader(file.relativePath, document, file.workspaceId);
+        for (const entry of fileEntries) {
+          const metadata = toSecretReferenceMetadata(entry.value);
+          const resolvedValue = await resolveSecretValue(entry.value, context.processEnv);
+          entries.push({
+            ...entry,
+            value: resolvedValue,
+            ...metadata ? { metadata } : {}
+          });
+        }
+      }
+      return entries;
+    }
+  };
+}
+
+// ../../plugins/filesystem/src/filesystemValuesReader.ts
+import { readFile as readFile2 } from "fs/promises";
+function filesystemValuesReader(filePath, document, workspaceId = "default") {
+  return yamlObjectToEntries(document, filePath, "value", "filesystem-values", workspaceId);
+}
+function createFilesystemValuesPlugin() {
+  return {
+    id: "filesystem-values",
+    kind: "loader",
+    async load(context) {
+      const sourceRoot = String(context.manifestConfig.root ?? "./");
+      const files = await collectFilesystemLayerFiles(
+        context.manifestRoot,
+        context.workspace.workspaceRoots,
+        sourceRoot,
+        context.profileActivation.values
+      );
+      const entries = [];
+      for (const file of files) {
+        const document = await readFile2(file.absolutePath, "utf8");
+        entries.push(...filesystemValuesReader(file.relativePath, document, file.workspaceId));
+      }
+      return entries;
+    }
+  };
+}
+
+export {
+  collectFilesystemLayerFiles,
+  yamlObjectToEntries,
+  filesystemSecretsReader,
+  createFilesystemSecretsPlugin,
+  filesystemValuesReader,
+  createFilesystemValuesPlugin
+};

package/dist/chunk-QNGS4HFP.js

@@ -0,0 +1,109 @@
+import {
+  envVarToLogicalKey,
+  resolveWorkspaceScopedPath,
+  toPortablePath
+} from "./chunk-D7AYK7X5.js";
+
+// ../../plugins/dotenv/src/index.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var DOTENV_PLUGIN_ID = "@kitsy/cnos/plugins/dotenv";
+function parseDoubleQuoted(value) {
+  return value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function parseDotenv(document) {
+  const parsed = {};
+  for (const rawLine of document.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const separatorIndex = withoutExport.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const envVar = withoutExport.slice(0, separatorIndex).trim();
+    let value = withoutExport.slice(separatorIndex + 1).trim();
+    if (!envVar) {
+      continue;
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = parseDoubleQuoted(value.slice(1, -1));
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    } else {
+      value = value.replace(/\s+#.*$/, "").trim();
+    }
+    parsed[envVar] = value;
+  }
+  return parsed;
+}
+function dotenvEntriesFromObject(values, mapping = {}, originFile, workspaceId = "default") {
+  return Object.entries(values).flatMap(([envVar, value]) => {
+    const logicalKey = envVarToLogicalKey(envVar, mapping);
+    if (!logicalKey) {
+      return [];
+    }
+    return [
+      {
+        key: logicalKey,
+        value,
+        namespace: logicalKey.startsWith("secret.") ? "secret" : "value",
+        sourceId: "dotenv",
+        pluginId: DOTENV_PLUGIN_ID,
+        workspaceId,
+        origin: {
+          envVar,
+          ...originFile ? { file: originFile } : {}
+        }
+      }
+    ];
+  });
+}
+async function readIfPresent(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function createDotenvPlugin() {
+  return {
+    id: "dotenv",
+    kind: "loader",
+    async load(context) {
+      const config = context.manifestConfig;
+      const rootTemplate = config.root ?? "./env";
+      const fileNames = context.profileActivation.envFiles;
+      const entries = [];
+      for (const workspaceRoot of context.workspace.workspaceRoots) {
+        const envRoot = resolveWorkspaceScopedPath(workspaceRoot.path, rootTemplate, {
+          workspace: workspaceRoot.workspaceId
+        });
+        for (const fileName of fileNames) {
+          const absolutePath = path.join(envRoot, fileName);
+          const document = await readIfPresent(absolutePath);
+          if (!document) {
+            continue;
+          }
+          entries.push(
+            ...dotenvEntriesFromObject(
+              parseDotenv(document),
+              config.envMapping,
+              toPortablePath(path.relative(path.dirname(context.manifestRoot), absolutePath)),
+              workspaceRoot.workspaceId
+            )
+          );
+        }
+      }
+      return entries;
+    }
+  };
+}
+
+export {
+  parseDotenv,
+  dotenvEntriesFromObject,
+  createDotenvPlugin
+};

package/dist/chunk-TYA4BNYT.js

@@ -0,0 +1,83 @@
+import {
+  joinConfigPath
+} from "./chunk-D7AYK7X5.js";
+
+// ../../plugins/cli-args/src/index.ts
+var CLI_ARGS_PLUGIN_ID = "@kitsy/cnos/plugins/cli-args";
+function isNamespaceName(value) {
+  return value === "value" || value === "secret";
+}
+function parseCliArgs(args) {
+  const parsed = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg?.startsWith("--")) {
+      continue;
+    }
+    if (arg === "--profile") {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--profile=")) {
+      continue;
+    }
+    const body = arg.slice(2);
+    const separatorIndex = body.indexOf("=");
+    if (separatorIndex >= 0) {
+      parsed.push({
+        key: body.slice(0, separatorIndex),
+        value: body.slice(separatorIndex + 1),
+        raw: arg
+      });
+      continue;
+    }
+    const nextValue = args[index + 1];
+    if (nextValue && !nextValue.startsWith("--")) {
+      parsed.push({
+        key: body,
+        value: nextValue,
+        raw: `${arg} ${nextValue}`
+      });
+      index += 1;
+    }
+  }
+  return parsed;
+}
+function cliArgEntriesFromArgs(args, workspaceId = "default") {
+  return parseCliArgs(args).flatMap(({ key, value, raw }) => {
+    const [candidateNamespace = "", ...pathSegments] = key.split(".");
+    if (!isNamespaceName(candidateNamespace) || pathSegments.length === 0) {
+      return [];
+    }
+    const namespace = candidateNamespace;
+    const logicalKey = `${namespace}.${joinConfigPath(pathSegments.join("."))}`;
+    return [
+      {
+        key: logicalKey,
+        value,
+        namespace,
+        sourceId: "cli-args",
+        pluginId: CLI_ARGS_PLUGIN_ID,
+        workspaceId,
+        origin: {
+          cliArg: raw
+        }
+      }
+    ];
+  });
+}
+function createCliArgsPlugin() {
+  return {
+    id: "cli-args",
+    kind: "loader",
+    async load(context) {
+      return cliArgEntriesFromArgs(context.cliArgs ?? [], context.workspace.workspaceId);
+    }
+  };
+}
+
+export {
+  parseCliArgs,
+  cliArgEntriesFromArgs,
+  createCliArgsPlugin
+};

package/dist/chunk-V4LCFDBY.js

@@ -0,0 +1,35 @@
+import {
+  toEnv,
+  toPublicEnv
+} from "./chunk-D7AYK7X5.js";
+
+// ../../plugins/env-export/src/index.ts
+function createEnvExportPlugin() {
+  return {
+    id: "@kitsy/cnos/plugins/env-export",
+    kind: "exporter",
+    async export(graph, context) {
+      return {
+        pluginId: "@kitsy/cnos/plugins/env-export",
+        value: toEnv(graph, context.manifest)
+      };
+    }
+  };
+}
+function createPublicEnvExportPlugin() {
+  return {
+    id: "@kitsy/cnos/plugins/public-env-export",
+    kind: "exporter",
+    async export(graph, context) {
+      return {
+        pluginId: "@kitsy/cnos/plugins/public-env-export",
+        value: toPublicEnv(graph, context.manifest)
+      };
+    }
+  };
+}
+
+export {
+  createEnvExportPlugin,
+  createPublicEnvExportPlugin
+};

package/dist/envNaming-BrOk5ndZ.d.cts

@@ -0,0 +1,8 @@
+import { N as NormalizedManifest, g as LogicalKey } from './plugin-BVNEHj19.cjs';
+
+interface EnvMappingConfig {
+    convention?: NormalizedManifest['envMapping']['convention'];
+    explicit?: Record<string, LogicalKey>;
+}
+
+export type { EnvMappingConfig as E };

package/dist/envNaming-DCaNdnrF.d.ts

@@ -0,0 +1,8 @@
+import { N as NormalizedManifest, g as LogicalKey } from './plugin-BVNEHj19.js';
+
+interface EnvMappingConfig {
+    convention?: NormalizedManifest['envMapping']['convention'];
+    explicit?: Record<string, LogicalKey>;
+}
+
+export type { EnvMappingConfig as E };