@kitsy/cnos 0.0.1 → 1.0.1

package/dist/plugin/dotenv.cjs

@@ -1,8 +1,14 @@
 "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))
@@ -11,14 +17,217 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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/plugin/dotenv.ts
 var dotenv_exports = {};
+__export(dotenv_exports, {
+  createDotenvPlugin: () => createDotenvPlugin,
+  dotenvEntriesFromObject: () => dotenvEntriesFromObject,
+  parseDotenv: () => parseDotenv
+});
 module.exports = __toCommonJS(dotenv_exports);
-__reExport(dotenv_exports, require("@kitsy/cnos-plugin-dotenv"), module.exports);
+
+// ../../plugins/dotenv/src/index.ts
+var import_promises8 = require("fs/promises");
+var import_node_path8 = __toESM(require("path"), 1);
+
+// ../core/src/manifest/loadManifest.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// ../core/src/utils/path.ts
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function interpolatePathTemplate(template, tokens) {
+  return Object.entries(tokens).reduce(
+    (result, [token, value]) => result.replaceAll(`{${token}}`, value),
+    template
+  );
+}
+function stripWorkspaceTemplatePrefix(template) {
+  const normalized = template.replace(/\\/g, "/").replace(/^\.\//, "");
+  const marker = "workspaces/{workspace}";
+  if (normalized === marker) {
+    return ".";
+  }
+  if (normalized.startsWith(`${marker}/`)) {
+    return normalized.slice(marker.length + 1);
+  }
+  return template;
+}
+function resolveWorkspaceScopedPath(workspaceRoot, template, tokens) {
+  const relativeTemplate = stripWorkspaceTemplatePrefix(template);
+  const interpolated = interpolatePathTemplate(relativeTemplate, tokens);
+  return import_node_path.default.resolve(workspaceRoot, interpolated);
+}
+function toPortablePath(targetPath) {
+  return targetPath.replace(/\\/g, "/");
+}
+
+// ../core/src/utils/yaml.ts
+var import_yaml = require("yaml");
+
+// ../core/src/manifest/loadWorkspaceFile.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+
+// ../core/src/profiles/expandProfileChain.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
+
+// ../core/src/workspaces/resolveWorkspaceContext.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// ../core/src/utils/envNaming.ts
+function normalizeMappingConfig(config = {}) {
+  return {
+    convention: config.convention,
+    explicit: config.explicit ?? {}
+  };
+}
+function fromScreamingSnake(path9) {
+  return path9.split("_").map((segment) => segment.trim().toLowerCase()).filter(Boolean).join(".");
+}
+function envVarToLogicalKey(envVar, config = {}) {
+  const normalized = normalizeMappingConfig(config);
+  const explicitMatch = normalized.explicit[envVar];
+  if (explicitMatch) {
+    return explicitMatch;
+  }
+  if (normalized.convention !== "SCREAMING_SNAKE") {
+    return void 0;
+  }
+  if (envVar.startsWith("SECRET_")) {
+    const stripped = envVar.slice("SECRET_".length);
+    if (!stripped) {
+      return void 0;
+    }
+    return `secret.${fromScreamingSnake(stripped)}`;
+  }
+  if (!/^[A-Z][A-Z0-9_]*$/.test(envVar)) {
+    return void 0;
+  }
+  return `value.${fromScreamingSnake(envVar)}`;
+}
+
+// ../core/src/runtime/dump.ts
+var import_promises6 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+
+// ../core/src/utils/secretStore.ts
+var import_node_crypto = require("crypto");
+var import_promises7 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"), 1);
+
+// ../../plugins/dotenv/src/index.ts
+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 (0, import_promises8.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 = import_node_path8.default.join(envRoot, fileName);
+          const document = await readIfPresent(absolutePath);
+          if (!document) {
+            continue;
+          }
+          entries.push(
+            ...dotenvEntriesFromObject(
+              parseDotenv(document),
+              config.envMapping,
+              toPortablePath(import_node_path8.default.relative(import_node_path8.default.dirname(context.manifestRoot), absolutePath)),
+              workspaceRoot.workspaceId
+            )
+          );
+        }
+      }
+      return entries;
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("@kitsy/cnos-plugin-dotenv")
+  createDotenvPlugin,
+  dotenvEntriesFromObject,
+  parseDotenv
 });

package/dist/plugin/dotenv.d.cts

@@ -1 +1,8 @@
-export * from '@kitsy/cnos-plugin-dotenv';
+import { L as LoaderPlugin, f as ConfigEntry } from '../plugin-BVNEHj19.cjs';
+import { E as EnvMappingConfig } from '../envNaming-BrOk5ndZ.cjs';
+
+declare function parseDotenv(document: string): Record<string, string>;
+declare function dotenvEntriesFromObject(values: Record<string, string>, mapping?: EnvMappingConfig, originFile?: string, workspaceId?: string): ConfigEntry[];
+declare function createDotenvPlugin(): LoaderPlugin;
+
+export { createDotenvPlugin, dotenvEntriesFromObject, parseDotenv };

package/dist/plugin/dotenv.d.ts

@@ -1 +1,8 @@
-export * from '@kitsy/cnos-plugin-dotenv';
+import { L as LoaderPlugin, f as ConfigEntry } from '../plugin-BVNEHj19.js';
+import { E as EnvMappingConfig } from '../envNaming-DCaNdnrF.js';
+
+declare function parseDotenv(document: string): Record<string, string>;
+declare function dotenvEntriesFromObject(values: Record<string, string>, mapping?: EnvMappingConfig, originFile?: string, workspaceId?: string): ConfigEntry[];
+declare function createDotenvPlugin(): LoaderPlugin;
+
+export { createDotenvPlugin, dotenvEntriesFromObject, parseDotenv };

package/dist/plugin/dotenv.js

@@ -1,2 +1,11 @@
-// src/plugin/dotenv.ts
-export * from "@kitsy/cnos-plugin-dotenv";
+import {
+  createDotenvPlugin,
+  dotenvEntriesFromObject,
+  parseDotenv
+} from "../chunk-44JOQPSN.js";
+import "../chunk-K2T4R5WH.js";
+export {
+  createDotenvPlugin,
+  dotenvEntriesFromObject,
+  parseDotenv
+};

package/dist/plugin/env-export.cjs

@@ -1,8 +1,14 @@
 "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))
@@ -11,14 +17,227 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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/plugin/env-export.ts
 var env_export_exports = {};
+__export(env_export_exports, {
+  createEnvExportPlugin: () => createEnvExportPlugin,
+  createPublicEnvExportPlugin: () => createPublicEnvExportPlugin,
+  toEnv: () => toEnv,
+  toPublicEnv: () => toPublicEnv
+});
 module.exports = __toCommonJS(env_export_exports);
-__reExport(env_export_exports, require("@kitsy/cnos-plugin-env-export"), module.exports);
+
+// ../core/src/errors.ts
+var CnosError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var CnosManifestError = class extends CnosError {
+  constructor(message, manifestPath) {
+    super(manifestPath ? `${message} (${manifestPath})` : message);
+    this.manifestPath = manifestPath;
+  }
+  manifestPath;
+};
+
+// ../core/src/manifest/loadManifest.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// ../core/src/utils/path.ts
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// ../core/src/utils/yaml.ts
+var import_yaml = require("yaml");
+
+// ../core/src/manifest/loadWorkspaceFile.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+
+// ../core/src/profiles/expandProfileChain.ts
+var import_promises4 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
+
+// ../core/src/workspaces/resolveWorkspaceContext.ts
+var import_promises5 = require("fs/promises");
+var import_node_path5 = __toESM(require("path"), 1);
+
+// ../core/src/utils/envNaming.ts
+function normalizeMappingConfig(config = {}) {
+  return {
+    convention: config.convention,
+    explicit: config.explicit ?? {}
+  };
+}
+function toScreamingSnakeSegment(segment) {
+  return segment.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function toScreamingSnake(path8) {
+  return path8.split(".").map((segment) => toScreamingSnakeSegment(segment)).filter(Boolean).join("_");
+}
+function logicalKeyToEnvVar(key, config = {}) {
+  const normalized = normalizeMappingConfig(config);
+  const explicitEntry = Object.entries(normalized.explicit).find(([, logicalKey]) => logicalKey === key);
+  if (explicitEntry) {
+    return explicitEntry[0];
+  }
+  if (normalized.convention !== "SCREAMING_SNAKE") {
+    return void 0;
+  }
+  if (key.startsWith("value.")) {
+    return toScreamingSnake(key.slice("value.".length));
+  }
+  if (key.startsWith("secret.")) {
+    return `SECRET_${toScreamingSnake(key.slice("secret.".length))}`;
+  }
+  return void 0;
+}
+
+// ../core/src/runtime/toEnv.ts
+function fallbackLogicalKeyToEnvVar(key) {
+  if (key.startsWith("value.")) {
+    return key.slice("value.".length).replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+  }
+  if (key.startsWith("secret.")) {
+    const normalized = key.slice("secret.".length).replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+    return `SECRET_${normalized}`;
+  }
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function normalizeEnvValue(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function toEnv(graph, manifest, options = {}) {
+  const includeSecrets = options.includeSecrets ?? true;
+  const output = {};
+  const resolvedEntries = Array.from(graph.entries.values()).sort(
+    (left, right) => left.key.localeCompare(right.key)
+  );
+  for (const entry of resolvedEntries) {
+    if (entry.namespace === "meta") {
+      continue;
+    }
+    if (!includeSecrets && entry.namespace === "secret") {
+      continue;
+    }
+    const envVar = logicalKeyToEnvVar(entry.key, manifest.envMapping) ?? fallbackLogicalKeyToEnvVar(entry.key);
+    output[envVar] = normalizeEnvValue(entry.value);
+  }
+  return output;
+}
+
+// ../core/src/runtime/toPublicEnv.ts
+function fallbackValueEnvVar(key) {
+  return key.replace(/^value\./, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function normalizeEnvValue2(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function resolvePublicPrefix(manifest, options) {
+  if (options.prefix) {
+    return options.prefix;
+  }
+  if (!options.framework) {
+    return "";
+  }
+  const configuredPrefix = manifest.public.frameworks[options.framework];
+  if (!configuredPrefix) {
+    throw new CnosManifestError(`Unknown public framework prefix: ${options.framework}`);
+  }
+  return configuredPrefix;
+}
+function ensurePublicPromotionKey(key) {
+  if (!key.startsWith("value.")) {
+    throw new CnosManifestError(`public.promote may only contain value.* keys: ${key}`);
+  }
+}
+function toPublicEnv(graph, manifest, options = {}) {
+  const prefix = resolvePublicPrefix(manifest, options);
+  const output = {};
+  const promotions = [...manifest.public.promote].sort((left, right) => left.localeCompare(right));
+  for (const key of promotions) {
+    ensurePublicPromotionKey(key);
+    const resolved = graph.entries.get(key);
+    if (!resolved) {
+      continue;
+    }
+    const baseEnvVar = logicalKeyToEnvVar(key, manifest.envMapping) ?? fallbackValueEnvVar(key);
+    const envVar = prefix && !baseEnvVar.startsWith(prefix) ? `${prefix}${baseEnvVar}` : baseEnvVar;
+    output[envVar] = normalizeEnvValue2(resolved.value);
+  }
+  return output;
+}
+
+// ../core/src/runtime/dump.ts
+var import_promises6 = require("fs/promises");
+var import_node_path6 = __toESM(require("path"), 1);
+
+// ../core/src/utils/secretStore.ts
+var import_node_crypto = require("crypto");
+var import_promises7 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"), 1);
+
+// ../../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)
+      };
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("@kitsy/cnos-plugin-env-export")
+  createEnvExportPlugin,
+  createPublicEnvExportPlugin,
+  toEnv,
+  toPublicEnv
 });

package/dist/plugin/env-export.d.cts

@@ -1 +1,7 @@
-export * from '@kitsy/cnos-plugin-env-export';
+import { E as ExporterPlugin } from '../plugin-BVNEHj19.cjs';
+export { t as toEnv, a as toPublicEnv } from '../toPublicEnv-Dd152fFy.cjs';
+
+declare function createEnvExportPlugin(): ExporterPlugin;
+declare function createPublicEnvExportPlugin(): ExporterPlugin;
+
+export { createEnvExportPlugin, createPublicEnvExportPlugin };

package/dist/plugin/env-export.d.ts

@@ -1 +1,7 @@
-export * from '@kitsy/cnos-plugin-env-export';
+import { E as ExporterPlugin } from '../plugin-BVNEHj19.js';
+export { t as toEnv, a as toPublicEnv } from '../toPublicEnv-Gwz3xTK0.js';
+
+declare function createEnvExportPlugin(): ExporterPlugin;
+declare function createPublicEnvExportPlugin(): ExporterPlugin;
+
+export { createEnvExportPlugin, createPublicEnvExportPlugin };

package/dist/plugin/env-export.js

@@ -1,2 +1,14 @@
-// src/plugin/env-export.ts
-export * from "@kitsy/cnos-plugin-env-export";
+import {
+  createEnvExportPlugin,
+  createPublicEnvExportPlugin
+} from "../chunk-ASZ7I3JJ.js";
+import {
+  toEnv,
+  toPublicEnv
+} from "../chunk-K2T4R5WH.js";
+export {
+  createEnvExportPlugin,
+  createPublicEnvExportPlugin,
+  toEnv,
+  toPublicEnv
+};