veryfront 0.1.485 → 0.1.487

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

@@ -0,0 +1,48 @@
+// 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: Record<string, string>): string {
+  const lines: string[] = [];
+  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/src/src/agent/hosted-agent-service-config.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+function parseBooleanFlag(value: string): boolean {
+  return value === "true";
+}
+
+function splitAllowedOrigins(value: string): string[] {
+  return value.split(",").map((origin) => origin.trim());
+}
+
+const booleanFlagSchema = z.string().default("false").transform(parseBooleanFlag);
+
+export const hostedAgentServiceConfigSchema = z.object({
+  VERYFRONT_API_URL: z.string().url().default("https://api.veryfront.com"),
+  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+  PORT: z.coerce.number().default(3001),
+  OAUTH_PUBLIC_KEY: z.string().optional(),
+  VERYFRONT_STUDIO_MCP_URL: z.string().default(""),
+  VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: booleanFlagSchema,
+  VERYFRONT_ENABLE_DURABLE_TASK: booleanFlagSchema,
+  ALLOWED_ORIGINS: z.string().default("http://localhost:3000,http://veryfront.me:3000"),
+  OTEL_ENABLED: booleanFlagSchema,
+  OTEL_EXPORTER_OTLP_ENDPOINT: z.string().optional(),
+}).transform((env) => ({
+  VERYFRONT_API_URL: env.VERYFRONT_API_URL,
+  VERYFRONT_MCP_URL: `${env.VERYFRONT_API_URL}/mcp`,
+  VERYFRONT_STUDIO_MCP_URL: env.VERYFRONT_STUDIO_MCP_URL,
+  VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT: env.VERYFRONT_ENABLE_DURABLE_INVOKE_AGENT,
+  VERYFRONT_ENABLE_DURABLE_TASK: env.VERYFRONT_ENABLE_DURABLE_TASK,
+  NODE_ENV: env.NODE_ENV,
+  PORT: env.PORT,
+  OAUTH_PUBLIC_KEY: env.OAUTH_PUBLIC_KEY,
+  ALLOWED_ORIGINS: splitAllowedOrigins(env.ALLOWED_ORIGINS),
+  OTEL_ENABLED: env.OTEL_ENABLED,
+  OTEL_EXPORTER_OTLP_ENDPOINT: env.OTEL_EXPORTER_OTLP_ENDPOINT,
+}));
+
+export type HostedAgentServiceConfig = z.infer<typeof hostedAgentServiceConfigSchema>;
+export type HostedAgentServiceConfigInput = z.input<typeof hostedAgentServiceConfigSchema>;
+
+export function parseHostedAgentServiceConfig(
+  input: HostedAgentServiceConfigInput,
+): HostedAgentServiceConfig {
+  return hostedAgentServiceConfigSchema.parse(input);
+}

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

@@ -273,6 +273,17 @@ export {
   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,

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.485";
+export const VERSION = "0.1.487";