Spaces:
Running
Running
| import { readFile, writeFile, access } from "node:fs/promises"; | |
| import path from "node:path"; | |
| import { ENV_KEYS } from "../constants.js"; | |
| import type { PipelineMode } from "../types.js"; | |
| import { envFilePath, sourcePath } from "./paths.js"; | |
| const QUOTE_NEEDED = /[\s#"'=]/; | |
| function escapeValue(value: string): string { | |
| if (value === "") return '""'; | |
| if (!QUOTE_NEEDED.test(value)) return value; | |
| return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`; | |
| } | |
| function parseLine( | |
| line: string, | |
| ): { key: string; rawValue: string } | null { | |
| const trimmed = line.trim(); | |
| if (!trimmed || trimmed.startsWith("#")) return null; | |
| const idx = line.indexOf("="); | |
| if (idx < 0) return null; | |
| return { | |
| key: line.slice(0, idx).trim(), | |
| rawValue: line.slice(idx + 1), | |
| }; | |
| } | |
| export interface EnvFile { | |
| /** Original line content in file order. */ | |
| lines: string[]; | |
| /** Map of key -> index into `lines` for quick lookup/update. */ | |
| keyIndex: Map<string, number>; | |
| } | |
| export async function readEnvFile(filePath: string): Promise<EnvFile> { | |
| let text = ""; | |
| try { | |
| text = await readFile(filePath, "utf8"); | |
| } catch (err) { | |
| if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err; | |
| } | |
| const lines = text.length === 0 ? [] : text.split(/\r?\n/); | |
| if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop(); | |
| const keyIndex = new Map<string, number>(); | |
| lines.forEach((line, i) => { | |
| const parsed = parseLine(line); | |
| if (parsed) keyIndex.set(parsed.key, i); | |
| }); | |
| return { lines, keyIndex }; | |
| } | |
| export function setEnvValue(env: EnvFile, key: string, value: string): void { | |
| const newLine = `${key}=${escapeValue(value)}`; | |
| const existing = env.keyIndex.get(key); | |
| if (existing !== undefined) { | |
| env.lines[existing] = newLine; | |
| } else { | |
| env.lines.push(newLine); | |
| env.keyIndex.set(key, env.lines.length - 1); | |
| } | |
| } | |
| export function removeEnvValue(env: EnvFile, key: string): void { | |
| const existing = env.keyIndex.get(key); | |
| if (existing === undefined) return; | |
| env.lines.splice(existing, 1); | |
| env.keyIndex.clear(); | |
| env.lines.forEach((line, i) => { | |
| const parsed = parseLine(line); | |
| if (parsed) env.keyIndex.set(parsed.key, i); | |
| }); | |
| } | |
| export function applyEnvValues( | |
| env: EnvFile, | |
| values: Record<string, string | number | undefined>, | |
| ): void { | |
| for (const [key, value] of Object.entries(values)) { | |
| if (value === undefined) continue; | |
| setEnvValue(env, key, String(value)); | |
| } | |
| } | |
| export async function writeEnvFile( | |
| filePath: string, | |
| env: EnvFile, | |
| ): Promise<void> { | |
| const content = env.lines.join("\n") + "\n"; | |
| await writeFile(filePath, content, "utf8"); | |
| } | |
| export async function loadOrSeedEnv(): Promise<EnvFile> { | |
| const targetPath = envFilePath(); | |
| try { | |
| await access(targetPath); | |
| return await readEnvFile(targetPath); | |
| } catch { | |
| const examplePath = path.join(sourcePath(), ".env.example"); | |
| return await readEnvFile(examplePath); | |
| } | |
| } | |
| export async function saveEnv(env: EnvFile): Promise<void> { | |
| await writeEnvFile(envFilePath(), env); | |
| } | |
| export async function setPipelineMode(mode: PipelineMode): Promise<void> { | |
| const targetPath = envFilePath(); | |
| const env = await readEnvFile(targetPath); | |
| setEnvValue(env, ENV_KEYS.pipelineMode, mode); | |
| await writeEnvFile(targetPath, env); | |
| } | |
| export function getEnvValue(env: EnvFile, key: string): string | undefined { | |
| const idx = env.keyIndex.get(key); | |
| if (idx === undefined) return undefined; | |
| const raw = (env.lines[idx] ?? "").split("=").slice(1).join("="); | |
| return raw.trim().replace(/^"|"$/g, ""); | |
| } | |
| export function resolvedModelsMode(env: EnvFile): "local" | "remote" { | |
| const small = getEnvValue(env, "LLM_SMALL_PROVIDER"); | |
| const large = getEnvValue(env, "LLM_LARGE_PROVIDER"); | |
| const embeddings = getEnvValue(env, "EMBEDDINGS_PROVIDER"); | |
| if (small === "ollama" && large === "ollama" && embeddings === "ollama") { | |
| return "local"; | |
| } | |
| const mode = getEnvValue(env, "MODELS_MODE"); | |
| if (mode === "local" || mode === "remote") return mode; | |
| return "remote"; | |
| } | |
| export function envFileToProcessEnv(env: EnvFile): NodeJS.ProcessEnv { | |
| const out: Record<string, string> = {}; | |
| for (const [key, idx] of env.keyIndex.entries()) { | |
| const value = getEnvValue(env, key); | |
| if (value !== undefined) out[key] = value; | |
| } | |
| out.MODELS_MODE = resolvedModelsMode(env); | |
| return { ...process.env, ...out }; | |
| } | |