veryfront 0.1.486 → 0.1.487

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.486",
+    "version": "0.1.487",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "workspace": [

package/esm/deps/jsr.io/@std/dotenv/0.225.6/mod.d.ts

@@ -0,0 +1,164 @@
+export * from "./stringify.js";
+export * from "./parse.js";
+/** Options for {@linkcode load} and {@linkcode loadSync}. */
+export interface LoadOptions {
+    /**
+     * Optional path to `.env` file. To prevent the default value from being
+     * used, set to `null`.
+     *
+     * @default {"./.env"}
+     */
+    envPath?: string | URL | null;
+    /**
+     * Set to `true` to export all `.env` variables to the current processes
+     * environment. Variables are then accessible via `Deno.env.get(<key>)`.
+     *
+     * @default {false}
+     */
+    export?: boolean;
+}
+/**
+ * Works identically to {@linkcode load}, but synchronously.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { loadSync } from "@std/dotenv";
+ *
+ * const conf = loadSync();
+ * ```
+ *
+ * @param options Options for loading the environment variables.
+ * @returns The parsed environment variables.
+ */
+export declare function loadSync(options?: LoadOptions): Record<string, string>;
+/**
+ * Load environment variables from a `.env` file.  Loaded variables are accessible
+ * in a configuration object returned by the `load()` function, as well as optionally
+ * exporting them to the process environment using the `export` option.
+ *
+ * Inspired by the node modules {@linkcode https://github.com/motdotla/dotenv | dotenv}
+ * and {@linkcode https://github.com/motdotla/dotenv-expand | dotenv-expand}.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * ## Basic usage
+ * ```sh
+ * # .env
+ * GREETING=hello world
+ * ```
+ *
+ * Then import the environment variables using the `load` function.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * // app.ts
+ * import { load } from "@std/dotenv";
+ *
+ * console.log(await load({ export: true })); // { GREETING: "hello world" }
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * .env files support blank lines, comments, multi-line values and more.
+ * See Parsing Rules below for more detail.
+ *
+ * ## Auto loading
+ * Import the `load.ts` module to auto-import from the `.env` file and into
+ * the process environment.
+ *
+ * @example Auto-loading
+ * ```ts ignore
+ * // app.ts
+ * import "@std/dotenv/load";
+ *
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * ## Files
+ * Dotenv supports a number of different files, all of which are optional.
+ * File names and paths are configurable.
+ *
+ * |File|Purpose|
+ * |----|-------|
+ * |.env|primary file for storing key-value environment entries
+ *
+ * ## Configuration
+ *
+ * Loading environment files comes with a number of options passed into
+ * the `load()` function, all of which are optional.
+ *
+ * |Option|Default|Description
+ * |------|-------|-----------
+ * |envPath|./.env|Path and filename of the `.env` file.  Use null to prevent the .env file from being loaded.
+ * |export|false|When true, this will export all environment variables in the `.env` file to the process environment (e.g. for use by `Deno.env.get()`) but only if they are not already set.  If a variable is already in the process, the `.env` value is ignored.
+ *
+ * ### Example configuration
+ *
+ * @example Using with options
+ * ```ts ignore
+ * import { load } from "@std/dotenv";
+ *
+ * const conf = await load({
+ *   envPath: "./.env_prod", // Uses .env_prod instead of .env
+ *   export: true, // Exports all variables to the environment
+ * });
+ * ```
+ *
+ * ## Permissions
+ *
+ * At a minimum, loading the `.env` related files requires the `--allow-read` permission.  Additionally, if
+ * you access the process environment, either through exporting your configuration or expanding variables
+ * in your `.env` file, you will need the `--allow-env` permission.  E.g.
+ *
+ * ```sh
+ * deno run --allow-read=.env --allow-env=ENV1,ENV2 app.ts
+ * ```
+ *
+ * ## Parsing Rules
+ *
+ * The parsing engine currently supports the following rules:
+ *
+ * - Variables that already exist in the environment are not overridden with
+ *   `export: true`
+ * - `BASIC=basic` becomes `{ BASIC: "basic" }`
+ * - empty lines are skipped
+ * - lines beginning with `#` are treated as comments
+ * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`)
+ * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes
+ *   `{ SINGLE_QUOTE: "quoted" }`)
+ * - new lines are expanded in double quoted values (`MULTILINE="new\nline"`
+ *   becomes
+ *
+ * ```
+ * { MULTILINE: "new\nline" }
+ * ```
+ *
+ * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes
+ *   `{ JSON: "{\"foo\": \"bar\"}" }`)
+ * - whitespace is removed from both ends of unquoted values (see more on
+ *   {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim | trim})
+ *   (`FOO= some value` becomes `{ FOO: "some value" }`)
+ * - whitespace is preserved on both ends of quoted values (`FOO=" some value "`
+ *   becomes `{ FOO: " some value " }`)
+ * - dollar sign with an environment key in or without curly braces in unquoted
+ *   values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }`)
+ * - escaped dollar sign with an environment key in unquoted values will escape the
+ *   environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`)
+ * - colon and a minus sign with a default value(which can also be another expand
+ *   value) in expanding construction in unquoted values will first attempt to
+ *   expand the environment key. If it’s not found, then it will return the default
+ *   value (`KEY=${KEY:-default}` If KEY exists it becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes
+ *   `{ KEY: "default" }`. Also there is possible to do this case
+ *   `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes
+ *   `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`)
+ *
+ * @param options The options
+ * @returns The parsed environment variables
+ */
+export declare function load(options?: LoadOptions): Promise<Record<string, string>>;
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/dotenv/0.225.6/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.6/mod.ts"],"names":[],"mappings":"AA4BA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAE3B,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC;IAE9B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,OAAO,GAAE,WAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgIG;AACH,wBAAsB,IAAI,CACxB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAejC"}

package/esm/deps/jsr.io/@std/dotenv/0.225.6/mod.js

@@ -0,0 +1,212 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+/**
+ * Parses and loads environment variables from a `.env` file into the current
+ * process, or stringify data into a `.env` file format.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * ```ts ignore
+ * // Automatically load environment variables from a `.env` file
+ * import "@std/dotenv/load";
+ * ```
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/dotenv";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(parse("GREETING=hello world"), { GREETING: "hello world" });
+ * assertEquals(stringify({ GREETING: "hello world" }), "GREETING='hello world'");
+ * ```
+ *
+ * @module
+ */
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { parse } from "./parse.js";
+export * from "./stringify.js";
+export * from "./parse.js";
+/**
+ * Works identically to {@linkcode load}, but synchronously.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { loadSync } from "@std/dotenv";
+ *
+ * const conf = loadSync();
+ * ```
+ *
+ * @param options Options for loading the environment variables.
+ * @returns The parsed environment variables.
+ */
+export function loadSync(options = {}) {
+    const { envPath = ".env", export: _export = false, } = options;
+    const conf = envPath ? parseFileSync(envPath) : {};
+    if (_export) {
+        for (const [key, value] of Object.entries(conf)) {
+            if (dntShim.Deno.env.get(key) !== undefined)
+                continue;
+            dntShim.Deno.env.set(key, value);
+        }
+    }
+    return conf;
+}
+/**
+ * Load environment variables from a `.env` file.  Loaded variables are accessible
+ * in a configuration object returned by the `load()` function, as well as optionally
+ * exporting them to the process environment using the `export` option.
+ *
+ * Inspired by the node modules {@linkcode https://github.com/motdotla/dotenv | dotenv}
+ * and {@linkcode https://github.com/motdotla/dotenv-expand | dotenv-expand}.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * ## Basic usage
+ * ```sh
+ * # .env
+ * GREETING=hello world
+ * ```
+ *
+ * Then import the environment variables using the `load` function.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * // app.ts
+ * import { load } from "@std/dotenv";
+ *
+ * console.log(await load({ export: true })); // { GREETING: "hello world" }
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * .env files support blank lines, comments, multi-line values and more.
+ * See Parsing Rules below for more detail.
+ *
+ * ## Auto loading
+ * Import the `load.ts` module to auto-import from the `.env` file and into
+ * the process environment.
+ *
+ * @example Auto-loading
+ * ```ts ignore
+ * // app.ts
+ * import "@std/dotenv/load";
+ *
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * ## Files
+ * Dotenv supports a number of different files, all of which are optional.
+ * File names and paths are configurable.
+ *
+ * |File|Purpose|
+ * |----|-------|
+ * |.env|primary file for storing key-value environment entries
+ *
+ * ## Configuration
+ *
+ * Loading environment files comes with a number of options passed into
+ * the `load()` function, all of which are optional.
+ *
+ * |Option|Default|Description
+ * |------|-------|-----------
+ * |envPath|./.env|Path and filename of the `.env` file.  Use null to prevent the .env file from being loaded.
+ * |export|false|When true, this will export all environment variables in the `.env` file to the process environment (e.g. for use by `Deno.env.get()`) but only if they are not already set.  If a variable is already in the process, the `.env` value is ignored.
+ *
+ * ### Example configuration
+ *
+ * @example Using with options
+ * ```ts ignore
+ * import { load } from "@std/dotenv";
+ *
+ * const conf = await load({
+ *   envPath: "./.env_prod", // Uses .env_prod instead of .env
+ *   export: true, // Exports all variables to the environment
+ * });
+ * ```
+ *
+ * ## Permissions
+ *
+ * At a minimum, loading the `.env` related files requires the `--allow-read` permission.  Additionally, if
+ * you access the process environment, either through exporting your configuration or expanding variables
+ * in your `.env` file, you will need the `--allow-env` permission.  E.g.
+ *
+ * ```sh
+ * deno run --allow-read=.env --allow-env=ENV1,ENV2 app.ts
+ * ```
+ *
+ * ## Parsing Rules
+ *
+ * The parsing engine currently supports the following rules:
+ *
+ * - Variables that already exist in the environment are not overridden with
+ *   `export: true`
+ * - `BASIC=basic` becomes `{ BASIC: "basic" }`
+ * - empty lines are skipped
+ * - lines beginning with `#` are treated as comments
+ * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`)
+ * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes
+ *   `{ SINGLE_QUOTE: "quoted" }`)
+ * - new lines are expanded in double quoted values (`MULTILINE="new\nline"`
+ *   becomes
+ *
+ * ```
+ * { MULTILINE: "new\nline" }
+ * ```
+ *
+ * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes
+ *   `{ JSON: "{\"foo\": \"bar\"}" }`)
+ * - whitespace is removed from both ends of unquoted values (see more on
+ *   {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim | trim})
+ *   (`FOO= some value` becomes `{ FOO: "some value" }`)
+ * - whitespace is preserved on both ends of quoted values (`FOO=" some value "`
+ *   becomes `{ FOO: " some value " }`)
+ * - dollar sign with an environment key in or without curly braces in unquoted
+ *   values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }`)
+ * - escaped dollar sign with an environment key in unquoted values will escape the
+ *   environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`)
+ * - colon and a minus sign with a default value(which can also be another expand
+ *   value) in expanding construction in unquoted values will first attempt to
+ *   expand the environment key. If it’s not found, then it will return the default
+ *   value (`KEY=${KEY:-default}` If KEY exists it becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes
+ *   `{ KEY: "default" }`. Also there is possible to do this case
+ *   `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes
+ *   `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`)
+ *
+ * @param options The options
+ * @returns The parsed environment variables
+ */
+export async function load(options = {}) {
+    const { envPath = ".env", export: _export = false, } = options;
+    const conf = envPath ? await parseFile(envPath) : {};
+    if (_export) {
+        for (const [key, value] of Object.entries(conf)) {
+            if (dntShim.Deno.env.get(key) !== undefined)
+                continue;
+            dntShim.Deno.env.set(key, value);
+        }
+    }
+    return conf;
+}
+function parseFileSync(filepath) {
+    try {
+        return parse(dntShim.Deno.readTextFileSync(filepath));
+    }
+    catch (e) {
+        if (e instanceof dntShim.Deno.errors.NotFound)
+            return {};
+        throw e;
+    }
+}
+async function parseFile(filepath) {
+    try {
+        return parse(await dntShim.Deno.readTextFile(filepath));
+    }
+    catch (e) {
+        if (e instanceof dntShim.Deno.errors.NotFound)
+            return {};
+        throw e;
+    }
+}

package/esm/deps/jsr.io/@std/dotenv/0.225.6/parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse `.env` file output in an object.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/dotenv/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const env = parse("GREETING=hello world");
+ * assertEquals(env, { GREETING: "hello world" });
+ * ```
+ *
+ * @param text The text to parse.
+ * @returns The parsed object.
+ */
+export declare function parse(text: string): Record<string, string>;
+//# sourceMappingURL=parse.d.ts.map

package/esm/deps/jsr.io/@std/dotenv/0.225.6/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.6/parse.ts"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoC1D"}

package/esm/deps/jsr.io/@std/dotenv/0.225.6/parse.js

@@ -0,0 +1,69 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+const KEY_VALUE_REGEXP = /^\s*(?:export\s+)?(?<key>[^\s=#]+?)\s*=[\ \t]*('\r?\n?(?<notInterpolated>(.|\r\n|\n)*?)\r?\n?'|"\r?\n?(?<interpolated>(.|\r\n|\n)*?)\r?\n?"|(?<unquoted>[^\r\n#]*)) *#*.*$/gm;
+const VALID_KEY_REGEXP = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const EXPAND_VALUE_REGEXP = /(\${(?<inBrackets>.+?)(\:-(?<inBracketsDefault>.+))?}|(?<!\\)\$(?<notInBrackets>\w+)(\:-(?<notInBracketsDefault>.+))?)/g;
+const CHARACTERS_MAP = {
+    "\\n": "\n",
+    "\\r": "\r",
+    "\\t": "\t",
+};
+function expandCharacters(str) {
+    return str.replace(/\\([nrt])/g, ($1) => CHARACTERS_MAP[$1] ?? "");
+}
+function expand(str, variablesMap) {
+    let current = str;
+    while (EXPAND_VALUE_REGEXP.test(current)) {
+        current = current.replace(EXPAND_VALUE_REGEXP, (...params) => {
+            const { inBrackets, inBracketsDefault, notInBrackets, notInBracketsDefault, } = params.at(-1);
+            const expandValue = inBrackets ?? notInBrackets;
+            const defaultValue = inBracketsDefault ?? notInBracketsDefault;
+            return (variablesMap[expandValue] ?? dntShim.Deno.env.get(expandValue) ?? defaultValue);
+        });
+    }
+    return current;
+}
+/**
+ * Parse `.env` file output in an object.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/dotenv/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const env = parse("GREETING=hello world");
+ * assertEquals(env, { GREETING: "hello world" });
+ * ```
+ *
+ * @param text The text to parse.
+ * @returns The parsed object.
+ */
+export function parse(text) {
+    const env = Object.create(null);
+    const keysForExpandCheck = [];
+    for (const match of text.matchAll(KEY_VALUE_REGEXP)) {
+        const { key, interpolated, notInterpolated, unquoted } = match
+            ?.groups;
+        if (!VALID_KEY_REGEXP.test(key)) {
+            // deno-lint-ignore no-console
+            console.warn(`Ignored the key "${key}" as it is not a valid identifier: The key need to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.`);
+            continue;
+        }
+        if (unquoted) {
+            keysForExpandCheck.push(key);
+        }
+        env[key] = typeof notInterpolated === "string"
+            ? notInterpolated
+            : typeof interpolated === "string"
+                ? expandCharacters(interpolated)
+                : unquoted.trim();
+    }
+    //https://github.com/motdotla/dotenv-expand/blob/ed5fea5bf517a09fd743ce2c63150e88c8a5f6d1/lib/main.js#L23
+    const variablesMap = { ...env };
+    for (const key of keysForExpandCheck) {
+        env[key] = expand(env[key], variablesMap);
+    }
+    return env;
+}

package/esm/deps/jsr.io/@std/dotenv/0.225.6/stringify.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stringify an object into a valid `.env` file format.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/dotenv/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const object = { GREETING: "hello world" };
+ * assertEquals(stringify(object), "GREETING='hello world'");
+ * ```
+ *
+ * @param object object to be stringified
+ * @returns string of object
+ */
+export declare function stringify(object: Record<string, string>): string;
+//# sourceMappingURL=stringify.d.ts.map

package/esm/deps/jsr.io/@std/dotenv/0.225.6/stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.6/stringify.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CA6BhE"}

package/esm/deps/jsr.io/@std/dotenv/0.225.6/stringify.js

@@ -0,0 +1,45 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Stringify an object into a valid `.env` file format.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/dotenv/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const object = { GREETING: "hello world" };
+ * assertEquals(stringify(object), "GREETING='hello world'");
+ * ```
+ *
+ * @param object object to be stringified
+ * @returns string of object
+ */
+export function stringify(object) {
+    const lines = [];
+    for (const [key, value] of Object.entries(object)) {
+        let quote;
+        let escapedValue = value ?? "";
+        if (key.startsWith("#")) {
+            // deno-lint-ignore no-console
+            console.warn(`key starts with a '#' indicates a comment and is ignored: '${key}'`);
+            continue;
+        }
+        else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
+            // escape inner new lines
+            escapedValue = escapedValue.replaceAll("\n", "\\n");
+            quote = `"`;
+        }
+        else if (escapedValue.match(/\W/)) {
+            quote = "'";
+        }
+        if (quote) {
+            // escape inner quotes
+            escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
+            escapedValue = `${quote}${escapedValue}${quote}`;
+        }
+        const line = `${key}=${escapedValue}`;
+        lines.push(line);
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,10 @@
+export type HostedAgentServiceEnvFileLoadResult = {
+    loadedFiles: string[];
+    loadedVariables: number;
+};
+export type HostedAgentServiceEnvFileLoadOptions = {
+    cwd?: string;
+    files?: readonly string[];
+};
+export declare function loadHostedAgentServiceEnvFiles(options?: HostedAgentServiceEnvFileLoadOptions): Promise<HostedAgentServiceEnvFileLoadResult>;
+//# sourceMappingURL=hosted-agent-service-env-files.d.ts.map

package/esm/src/agent/hosted-agent-service-env-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-agent-service-env-files.d.ts","sourceRoot":"","sources":["../../../src/src/agent/hosted-agent-service-env-files.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,mCAAmC,GAAG;IAChD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B,CAAC;AAUF,wBAAsB,8BAA8B,CAClD,OAAO,GAAE,oCAAyC,GACjD,OAAO,CAAC,mCAAmC,CAAC,CA6B9C"}

package/esm/src/agent/hosted-agent-service-env-files.js

@@ -0,0 +1,33 @@
+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"];
+function joinEnvPath(cwd, file) {
+    if (file.startsWith("/") || file.startsWith("./") || file.startsWith("../")) {
+        return file;
+    }
+    return `${cwd.replace(/\/$/, "")}/${file}`;
+}
+export async function loadHostedAgentServiceEnvFiles(options = {}) {
+    const cwd = options.cwd ?? getCwd();
+    const files = options.files ?? DEFAULT_HOSTED_AGENT_SERVICE_ENV_FILES;
+    const protectedKeys = new Set(Object.keys(getProcessEnv()));
+    const loadedFiles = [];
+    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/esm/src/agent/index.d.ts

@@ -100,6 +100,7 @@ export { createDefaultHostedChatRuntime, type CreateDefaultHostedChatRuntimeCont
 export { createDefaultHostedProjectSteeringRefresh, type CreateDefaultHostedProjectSteeringRefreshOptions, type DefaultHostedProjectSteeringRefreshLogger, type DefaultHostedProjectSteeringRefreshLookup, } from "./default-hosted-project-steering-refresh.js";
 export { createHostedAgentServiceRuntime, type CreateHostedAgentServiceRuntimeOptions, type HostedAgentServiceRuntimeBundle, type HostedAgentServiceRuntimeConfig, type HostedAgentServiceRuntimeLogger, type HostedAgentServiceRuntimeTrace, startNodeHostedAgentService, type StartNodeHostedAgentServiceOptions, type StartNodeHostedAgentServiceResult, } from "./hosted-agent-service-runtime.js";
 export { type HostedAgentServiceConfig, type HostedAgentServiceConfigInput, 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, type AgentServiceTraceContextGetter, bootstrapAgentService, type BootstrapAgentServiceOptions, runAgentServiceMain, type RunAgentServiceMainOptions, } from "./agent-service-bootstrap.js";
 export { type AbortRejectionEvent, type AbortRejectionEventTarget, type AbortRejectionGuardLogger, type AbortRejectionProcessTarget, installAbortRejectionGuard, type InstallAbortRejectionGuardOptions, type InstalledAbortRejectionGuard, isAbortRejectionReason, } from "./abort-rejection-guard.js";
 export { type CachedRequestAuthResult, createRequestAuthCache, type CreateRequestAuthCacheOptions, type RequestAuthCache, } from "./request-auth-cache.js";