veryfront 0.1.486 → 0.1.488

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-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

@@ -186,6 +186,11 @@ export {
   runtimeAgentThinkingConfigSchema,
 } from "./runtime-agent-definition.js";
 
+export {
+  createVeryfrontCloudRuntimeSystemMessages,
+  type CreateVeryfrontCloudRuntimeSystemMessagesInput,
+} from "./veryfront-cloud-runtime-system-messages.js";
+
 export {
   applyAgentProjectContextChange,
   getConfirmedProjectContextSwitchId,
@@ -279,6 +284,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/agent/veryfront-cloud-runtime-system-messages.ts

@@ -0,0 +1,65 @@
+import type { ChatSystemMessage } from "../chat/types.js";
+import {
+  createRuntimeAgentSystemMessages,
+  type RuntimeAgentMarkdownDefinition,
+} from "./runtime-agent-definition.js";
+import { createRuntimePromptBlock } from "./runtime-prompt-block.js";
+import type { RuntimeSkillDefinition } from "./runtime-skill-metadata.js";
+
+export type CreateVeryfrontCloudRuntimeSystemMessagesInput = {
+  agent: RuntimeAgentMarkdownDefinition;
+  instructions?: string;
+  skills?: readonly RuntimeSkillDefinition[];
+  projectId?: string | null;
+  branchId?: string | null;
+  environmentContext?: string;
+};
+
+function createProjectInstructionsBlock(instructions: string): string {
+  return createRuntimePromptBlock({
+    name: "project_instructions",
+    content: `CRITICAL: You MUST follow these project-specific guidelines:\n\n${instructions}`,
+  });
+}
+
+function createProjectContextBlock(input: { projectId: string; branchId?: string | null }): string {
+  const branchLine = input.branchId
+    ? `branch_id: "${input.branchId}"`
+    : "branch_id: main (no branch_id needed for file operations)";
+
+  return createRuntimePromptBlock({
+    name: "project_context",
+    content: `project_reference: "${input.projectId}"
+${branchLine}
+
+Use the exact project_reference above for project/platform tools unless a tool result explicitly confirms a different active project.
+
+CRITICAL: Do NOT guess or invent project references. If a tool requires project_reference, use the value above.`,
+  });
+}
+
+export function createVeryfrontCloudRuntimeSystemMessages(
+  input: CreateVeryfrontCloudRuntimeSystemMessagesInput,
+): ChatSystemMessage[] {
+  const runtimeBlocks: string[] = [];
+
+  if (input.instructions) {
+    runtimeBlocks.push(createProjectInstructionsBlock(input.instructions));
+  }
+
+  if (input.projectId) {
+    runtimeBlocks.push(
+      createProjectContextBlock({
+        projectId: input.projectId,
+        branchId: input.branchId,
+      }),
+    );
+  }
+
+  return createRuntimeAgentSystemMessages({
+    agent: input.agent,
+    runtimeBlocks,
+    skills: input.skills,
+    environmentContext: input.environmentContext,
+  });
+}

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.488";