@easynet/agent-common 1.0.2 → 1.0.4

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export { loadYamlFile, loadYamlFileSync, parseYamlContent, clearYamlFileCache, type LoadYamlOptions, type YamlEnvOptions, } from "./yaml.js";
+export { isPathRef, expandHomePath, resolveConfigPath, type ResolveConfigPathOptions, } from "./path.js";

package/dist/config/path.d.ts

@@ -0,0 +1,9 @@
+export interface ResolveConfigPathOptions {
+    expandHome?: boolean;
+    homeDir?: string;
+}
+export declare function isPathRef(value: unknown): value is string;
+export declare function expandHomePath(inputPath: string, options?: {
+    homeDir?: string;
+}): string;
+export declare function resolveConfigPath(pathRef: string, configDir: string, options?: ResolveConfigPathOptions): string;

package/dist/config/yaml.d.ts

@@ -0,0 +1,12 @@
+export interface YamlEnvOptions {
+    substituteEnv?: boolean;
+    missingEnv?: "keep" | "empty";
+    env?: NodeJS.ProcessEnv;
+}
+export interface LoadYamlOptions extends YamlEnvOptions {
+    cache?: boolean;
+}
+export declare function clearYamlFileCache(): void;
+export declare function parseYamlContent<T = unknown>(content: string, options?: YamlEnvOptions): T;
+export declare function loadYamlFileSync<T = unknown>(filePath: string, options?: LoadYamlOptions): T | undefined;
+export declare function loadYamlFile<T = unknown>(filePath: string, options?: LoadYamlOptions): Promise<T | undefined>;

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from "./npm/index.js";
+export * from "./config/index.js";

package/dist/index.js

@@ -20,17 +20,122 @@ import {
   resolveNpmPackageVersion,
   runNpmCommand
 } from "./chunk-UDSSVJ5F.js";
+
+// src/config/yaml.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import path from "path";
+import { parse as parseYaml } from "yaml";
+var YAML_CACHE = /* @__PURE__ */ new Map();
+function clearYamlFileCache() {
+  YAML_CACHE.clear();
+}
+function substituteEnvInString(input, env, missingEnv) {
+  return input.replace(/\$\{(\w+)\}/g, (_, name) => {
+    const value = env[name];
+    if (value !== void 0) return value;
+    return missingEnv === "empty" ? "" : `\${${name}}`;
+  });
+}
+function substituteEnvInValue(input, options) {
+  if (typeof input === "string") {
+    return substituteEnvInString(input, options.env, options.missingEnv);
+  }
+  if (Array.isArray(input)) {
+    return input.map((item) => substituteEnvInValue(item, options));
+  }
+  if (input && typeof input === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+      out[k] = substituteEnvInValue(v, options);
+    }
+    return out;
+  }
+  return input;
+}
+function parseYamlContent(content, options = {}) {
+  const parsed = parseYaml(content);
+  if (options.substituteEnv === false) return parsed;
+  return substituteEnvInValue(parsed, {
+    env: options.env ?? process.env,
+    missingEnv: options.missingEnv ?? "keep"
+  });
+}
+function readFromCache(filePath, mtimeMs) {
+  const cached = YAML_CACHE.get(filePath);
+  if (!cached) return void 0;
+  if (cached.mtimeMs !== mtimeMs) return void 0;
+  return cached.value;
+}
+function writeCache(filePath, mtimeMs, value) {
+  YAML_CACHE.set(filePath, { mtimeMs, value });
+}
+function loadYamlFileSync(filePath, options = {}) {
+  const absPath = path.resolve(filePath);
+  if (!existsSync(absPath)) return void 0;
+  const useCache = options.cache === true;
+  const fileStat = statSync(absPath);
+  if (useCache) {
+    const cached = readFromCache(absPath, fileStat.mtimeMs);
+    if (cached !== void 0) return cached;
+  }
+  const content = readFileSync(absPath, "utf-8");
+  const parsed = parseYamlContent(content, options);
+  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);
+  return parsed;
+}
+async function loadYamlFile(filePath, options = {}) {
+  const absPath = path.resolve(filePath);
+  let fileStat;
+  try {
+    fileStat = await stat(absPath);
+  } catch (err) {
+    if (err?.code === "ENOENT") return void 0;
+    throw err;
+  }
+  const useCache = options.cache === true;
+  if (useCache) {
+    const cached = readFromCache(absPath, fileStat.mtimeMs);
+    if (cached !== void 0) return cached;
+  }
+  const content = await readFile(absPath, "utf-8");
+  const parsed = parseYamlContent(content, options);
+  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);
+  return parsed;
+}
+
+// src/config/path.ts
+import path2 from "path";
+import { homedir } from "os";
+function isPathRef(value) {
+  return typeof value === "string" && value.length > 0 && (value.endsWith(".yaml") || value.endsWith(".yml"));
+}
+function expandHomePath(inputPath, options = {}) {
+  const home = options.homeDir ?? homedir();
+  if (inputPath === "~") return home;
+  if (inputPath.startsWith("~/")) return path2.join(home, inputPath.slice(2));
+  return inputPath;
+}
+function resolveConfigPath(pathRef, configDir, options = {}) {
+  const expanded = options.expandHome === false ? pathRef : expandHomePath(pathRef, { homeDir: options.homeDir });
+  return path2.resolve(configDir, expanded);
+}
 export {
   NPM_PROTOCOL_PREFIX,
   assertNpmCommandSuccess,
   clearVersionCache,
+  clearYamlFileCache,
   ensureNpmPackageInstalled,
   ensurePackageInCache,
+  expandHomePath,
   formatProviderDisplay,
   getInstalledVersion,
   getPackageEntryPath,
   importFromCache,
   isNpmProviderSpec,
+  isPathRef,
+  loadYamlFile,
+  loadYamlFileSync,
   npmInstall,
   npmPublish,
   npmRoot,
@@ -38,6 +143,8 @@ export {
   npmSearchJson,
   parseNpmProvider,
   parseNpmProviderSpec,
+  parseYamlContent,
+  resolveConfigPath,
   resolveLatestVersionFromRegistry,
   resolveNpmPackageVersion,
   runNpmCommand

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/config/yaml.ts","../src/config/path.ts"],"sourcesContent":["import { existsSync, readFileSync, statSync } from \"node:fs\";\nimport { readFile, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { parse as parseYaml } from \"yaml\";\n\nexport interface YamlEnvOptions {\n  substituteEnv?: boolean;\n  missingEnv?: \"keep\" | \"empty\";\n  env?: NodeJS.ProcessEnv;\n}\n\nexport interface LoadYamlOptions extends YamlEnvOptions {\n  cache?: boolean;\n}\n\ninterface CacheEntry {\n  mtimeMs: number;\n  value: unknown;\n}\n\nconst YAML_CACHE = new Map<string, CacheEntry>();\n\nexport function clearYamlFileCache(): void {\n  YAML_CACHE.clear();\n}\n\nfunction substituteEnvInString(\n  input: string,\n  env: NodeJS.ProcessEnv,\n  missingEnv: \"keep\" | \"empty\",\n): string {\n  return input.replace(/\\$\\{(\\w+)\\}/g, (_, name: string) => {\n    const value = env[name];\n    if (value !== undefined) return value;\n    return missingEnv === \"empty\" ? \"\" : `\\${${name}}`;\n  });\n}\n\nfunction substituteEnvInValue(\n  input: unknown,\n  options: { env: NodeJS.ProcessEnv; missingEnv: \"keep\" | \"empty\" },\n): unknown {\n  if (typeof input === \"string\") {\n    return substituteEnvInString(input, options.env, options.missingEnv);\n  }\n  if (Array.isArray(input)) {\n    return input.map((item) => substituteEnvInValue(item, options));\n  }\n  if (input && typeof input === \"object\") {\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(input)) {\n      out[k] = substituteEnvInValue(v, options);\n    }\n    return out;\n  }\n  return input;\n}\n\nexport function parseYamlContent<T = unknown>(\n  content: string,\n  options: YamlEnvOptions = {},\n): T {\n  const parsed = parseYaml(content) as unknown;\n  if (options.substituteEnv === false) return parsed as T;\n  return substituteEnvInValue(parsed, {\n    env: options.env ?? process.env,\n    missingEnv: options.missingEnv ?? \"keep\",\n  }) as T;\n}\n\nfunction readFromCache(filePath: string, mtimeMs: number): unknown | undefined {\n  const cached = YAML_CACHE.get(filePath);\n  if (!cached) return undefined;\n  if (cached.mtimeMs !== mtimeMs) return undefined;\n  return cached.value;\n}\n\nfunction writeCache(filePath: string, mtimeMs: number, value: unknown): void {\n  YAML_CACHE.set(filePath, { mtimeMs, value });\n}\n\nexport function loadYamlFileSync<T = unknown>(\n  filePath: string,\n  options: LoadYamlOptions = {},\n): T | undefined {\n  const absPath = path.resolve(filePath);\n  if (!existsSync(absPath)) return undefined;\n  const useCache = options.cache === true;\n  const fileStat = statSync(absPath);\n  if (useCache) {\n    const cached = readFromCache(absPath, fileStat.mtimeMs);\n    if (cached !== undefined) return cached as T;\n  }\n  const content = readFileSync(absPath, \"utf-8\");\n  const parsed = parseYamlContent<T>(content, options);\n  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);\n  return parsed;\n}\n\nexport async function loadYamlFile<T = unknown>(\n  filePath: string,\n  options: LoadYamlOptions = {},\n): Promise<T | undefined> {\n  const absPath = path.resolve(filePath);\n  let fileStat;\n  try {\n    fileStat = await stat(absPath);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException)?.code === \"ENOENT\") return undefined;\n    throw err;\n  }\n  const useCache = options.cache === true;\n  if (useCache) {\n    const cached = readFromCache(absPath, fileStat.mtimeMs);\n    if (cached !== undefined) return cached as T;\n  }\n  const content = await readFile(absPath, \"utf-8\");\n  const parsed = parseYamlContent<T>(content, options);\n  if (useCache) writeCache(absPath, fileStat.mtimeMs, parsed);\n  return parsed;\n}\n","import path from \"node:path\";\nimport { homedir } from \"node:os\";\n\nexport interface ResolveConfigPathOptions {\n  expandHome?: boolean;\n  homeDir?: string;\n}\n\nexport function isPathRef(value: unknown): value is string {\n  return (\n    typeof value === \"string\" &&\n    value.length > 0 &&\n    (value.endsWith(\".yaml\") || value.endsWith(\".yml\"))\n  );\n}\n\nexport function expandHomePath(inputPath: string, options: { homeDir?: string } = {}): string {\n  const home = options.homeDir ?? homedir();\n  if (inputPath === \"~\") return home;\n  if (inputPath.startsWith(\"~/\")) return path.join(home, inputPath.slice(2));\n  return inputPath;\n}\n\nexport function resolveConfigPath(\n  pathRef: string,\n  configDir: string,\n  options: ResolveConfigPathOptions = {},\n): string {\n  const expanded = options.expandHome === false ? pathRef : expandHomePath(pathRef, { homeDir: options.homeDir });\n  return path.resolve(configDir, expanded);\n}\n"],"mappings":"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","names":["path"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easynet/agent-common",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Shared runtime utilities for Easynet agent projects",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,8 +10,8 @@
       "npm": [
         "dist/npm/index.d.ts"
       ],
-      "*": [
-        "dist/*"
+      "config": [
+        "dist/config/index.d.ts"
       ]
     }
   },
@@ -23,6 +23,10 @@
     "./npm": {
       "types": "./dist/npm/index.d.ts",
       "import": "./dist/npm/index.js"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js"
     }
   },
   "files": [
@@ -35,6 +39,9 @@
     "test": "npm run build && npm run typecheck",
     "release": "semantic-release"
   },
+  "dependencies": {
+    "yaml": "^2.8.1"
+  },
   "devDependencies": {
     "@semantic-release/commit-analyzer": "^13.0.0",
     "@semantic-release/git": "^10.0.1",