veryfront 0.1.486 → 0.1.487

package/src/src/agent/hosted-agent-service-env-files.ts

@@ -0,0 +1,55 @@
+import { cwd as getCwd, env as getProcessEnv, setEnv } from "../platform/compat/process.js";
+import { load as loadDotenv } from "../platform/compat/std/dotenv.js";
+
+const DEFAULT_HOSTED_AGENT_SERVICE_ENV_FILES = [".env", ".env.local"] as const;
+
+export type HostedAgentServiceEnvFileLoadResult = {
+  loadedFiles: string[];
+  loadedVariables: number;
+};
+
+export type HostedAgentServiceEnvFileLoadOptions = {
+  cwd?: string;
+  files?: readonly string[];
+};
+
+function joinEnvPath(cwd: string, file: string): string {
+  if (file.startsWith("/") || file.startsWith("./") || file.startsWith("../")) {
+    return file;
+  }
+
+  return `${cwd.replace(/\/$/, "")}/${file}`;
+}
+
+export async function loadHostedAgentServiceEnvFiles(
+  options: HostedAgentServiceEnvFileLoadOptions = {},
+): Promise<HostedAgentServiceEnvFileLoadResult> {
+  const cwd = options.cwd ?? getCwd();
+  const files = options.files ?? DEFAULT_HOSTED_AGENT_SERVICE_ENV_FILES;
+  const protectedKeys = new Set(Object.keys(getProcessEnv()));
+  const loadedFiles: string[] = [];
+  let loadedVariables = 0;
+
+  for (const file of files) {
+    const envPath = joinEnvPath(cwd, file);
+    const parsed = await loadDotenv({ envPath, allowEmptyValues: true });
+    const entries = Object.entries(parsed);
+
+    if (entries.length === 0) {
+      continue;
+    }
+
+    loadedFiles.push(envPath);
+
+    for (const [key, value] of entries) {
+      if (protectedKeys.has(key)) {
+        continue;
+      }
+
+      setEnv(key, value);
+      loadedVariables++;
+    }
+  }
+
+  return { loadedFiles, loadedVariables };
+}

package/src/src/agent/index.ts

@@ -279,6 +279,11 @@ export {
   hostedAgentServiceConfigSchema,
   parseHostedAgentServiceConfig,
 } from "./hosted-agent-service-config.js";
+export {
+  type HostedAgentServiceEnvFileLoadOptions,
+  type HostedAgentServiceEnvFileLoadResult,
+  loadHostedAgentServiceEnvFiles,
+} from "./hosted-agent-service-env-files.js";
 export {
   type AgentServiceBootstrapExit,
   type AgentServiceTraceContext,

package/src/src/platform/compat/std/dotenv.ts

@@ -0,0 +1,87 @@
+/**
+ * Portable @std/dotenv shim for Node.js and Bun.
+ *
+ * In Deno: Uses @std/dotenv
+ * In Node.js/Bun: Provides a minimal .env file loader
+ *
+ * @module
+ */
+
+import { isDeno } from "../runtime.js";
+
+interface LoadOptions {
+  envPath?: string;
+  export?: boolean;
+  examplePath?: string | null;
+  allowEmptyValues?: boolean;
+  defaultsPath?: string | null;
+}
+
+function parseEnvFile(content: string, allowEmptyValues: boolean): Record<string, string> {
+  const result: Record<string, string> = {};
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+
+    const key = trimmed.slice(0, eqIndex).trim();
+    if (!key) continue;
+
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (!value && !allowEmptyValues) continue;
+
+    const firstChar = value[0];
+    if ((firstChar === `"` || firstChar === `'`) && value.endsWith(firstChar)) {
+      value = value.slice(1, -1);
+    }
+
+    if (value.includes("\\")) {
+      value = value
+        .replace(/\\n/g, "\n")
+        .replace(/\\r/g, "\r")
+        .replace(/\\t/g, "\t")
+        .replace(/\\\\/g, "\\");
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+async function nodeLoad(options: LoadOptions = {}): Promise<Record<string, string>> {
+  const { readFile } = await import("node:fs/promises");
+  const { resolve: pathResolve, join } = await import("node:path");
+  const { cwd } = await import("node:process");
+
+  const envPath = options.envPath ?? join(cwd(), ".env");
+  const shouldExport = options.export ?? false;
+
+  try {
+    const content = await readFile(pathResolve(envPath), "utf-8");
+    const parsed = parseEnvFile(content, options.allowEmptyValues ?? false);
+
+    if (shouldExport) {
+      for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === undefined) process.env[key] = value;
+      }
+    }
+
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+export let load: (options?: LoadOptions) => Promise<Record<string, string>>;
+
+if (isDeno) {
+  const stdDotenv = await import("../../../../deps/jsr.io/@std/dotenv/0.225.6/mod.js");
+  load = stdDotenv.load;
+} else {
+  load = nodeLoad;
+}

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.486";
+export const VERSION = "0.1.487";