veryfront 0.1.215 → 0.1.217

package/src/src/platform/compat/process/command.ts

@@ -0,0 +1,297 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { dynamicImport } from "../dynamic-import.js";
+import { isBun as IS_BUN, isDeno as IS_DENO } from "../runtime.js";
+import { isWindowsPlatform, runtimeProcess } from "./runtime-process.js";
+
+export interface CommandResult {
+  success: boolean;
+  code: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+export interface CommandOptions {
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  /** Capture stdout/stderr to return in result */
+  capture?: boolean;
+  /** Inherit stdio from parent process (shows output in terminal) */
+  inherit?: boolean;
+  /** Use shell to run the command (needed for .cmd files on Windows) */
+  shell?: boolean;
+  /** Kill the command if it exceeds this duration (milliseconds) */
+  timeoutMs?: number;
+}
+
+const COMMAND_TIMEOUT_EXIT_CODE = 124;
+const FORCE_KILL_GRACE_MS = 250;
+
+function createTimeoutResult(
+  timeoutMs: number,
+  stdout?: string,
+  stderr?: string,
+): CommandResult {
+  return {
+    success: false,
+    code: COMMAND_TIMEOUT_EXIT_CODE,
+    stdout,
+    stderr: `${stderr ?? ""}\nCommand timed out after ${timeoutMs}ms`.trim(),
+  };
+}
+
+function createProcessTimeout(
+  timeoutMs: number | undefined,
+  terminate: () => void,
+  forceTerminate: () => void,
+): { hasTimedOut: () => boolean; clear: () => void } {
+  let timedOut = false;
+  let timeoutId: ReturnType<typeof dntShim.setTimeout> | undefined;
+  let forceKillId: ReturnType<typeof dntShim.setTimeout> | undefined;
+
+  if (timeoutMs && timeoutMs > 0) {
+    timeoutId = dntShim.setTimeout(() => {
+      timedOut = true;
+      try {
+        terminate();
+      } catch (_) {
+        /* expected: best-effort terminate may fail if process already exited */
+      }
+
+      forceKillId = dntShim.setTimeout(() => {
+        try {
+          forceTerminate();
+        } catch (_) {
+          /* expected: best-effort force terminate may fail if process already exited */
+        }
+      }, FORCE_KILL_GRACE_MS);
+    }, timeoutMs);
+  }
+
+  return {
+    hasTimedOut: () => timedOut,
+    clear: () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (forceKillId) clearTimeout(forceKillId);
+    },
+  };
+}
+
+async function readStreamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+
+  const total = chunks.reduce((acc, c) => acc + c.length, 0);
+  const merged = new Uint8Array(total);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  return new TextDecoder().decode(merged);
+}
+
+/**
+ * Run a command and return the result.
+ * Works across Deno, Node.js, and Bun.
+ *
+ * @param cmd - Command to run
+ * @param options - Command options
+ * @param options.capture - Capture stdout/stderr to return in result
+ * @param options.inherit - Inherit stdio from parent (shows output in terminal)
+ * @param options.shell - Use shell to run command (needed for .cmd on Windows)
+ */
+export async function runCommand(
+  cmd: string,
+  options: CommandOptions = {},
+): Promise<CommandResult> {
+  const {
+    args = [],
+    cwd: cmdCwd,
+    env: cmdEnv,
+    capture = false,
+    inherit = false,
+    shell = false,
+    timeoutMs,
+  } = options;
+  const effectiveTimeoutMs = timeoutMs && timeoutMs > 0 ? Math.floor(timeoutMs) : undefined;
+
+  // Determine stdio mode: inherit > capture > null
+  const stdioMode = inherit ? "inherit" : capture ? "piped" : "null";
+
+  if (IS_DENO) {
+    const command = new dntShim.Deno.Command(cmd, {
+      args,
+      cwd: cmdCwd,
+      env: cmdEnv,
+      stdin: inherit ? "inherit" : "null",
+      stdout: stdioMode,
+      stderr: stdioMode,
+    });
+
+    const child = command.spawn();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
+
+    try {
+      const [status, stdout, stderr] = await Promise.all([
+        child.status,
+        capture && child.stdout ? readStreamToString(child.stdout) : Promise.resolve(undefined),
+        capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
+      ]);
+
+      if (timeout.hasTimedOut()) {
+        return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+      }
+
+      return {
+        success: status.success,
+        code: status.code,
+        stdout,
+        stderr,
+      };
+    } finally {
+      timeout.clear();
+    }
+  }
+
+  if (IS_BUN) {
+    const bunGlobal = dntShim.dntGlobalThis as unknown as {
+      Bun: {
+        spawn: (options: {
+          cmd: string[];
+          cwd?: string;
+          env?: Record<string, string>;
+          stdout?: "pipe" | "inherit" | "ignore";
+          stderr?: "pipe" | "inherit" | "ignore";
+        }) => {
+          exited: Promise<number>;
+          stdout: ReadableStream<Uint8Array> | null;
+          stderr: ReadableStream<Uint8Array> | null;
+          kill?: (signal?: string | number) => void;
+        };
+      };
+    };
+
+    const bunStdio = inherit ? "inherit" : capture ? "pipe" : "ignore";
+
+    const isWindows = isWindowsPlatform();
+    const bunCmd = shell
+      ? args.length === 0
+        ? isWindows ? ["cmd", "/c", cmd] : ["sh", "-c", cmd]
+        : isWindows
+        ? ["cmd", "/c", cmd, ...args]
+        : ["sh", "-c", 'exec "$@"', "sh", cmd, ...args]
+      : [cmd, ...args];
+
+    const proc = bunGlobal.Bun.spawn({
+      cmd: bunCmd,
+      cwd: cmdCwd,
+      env: cmdEnv,
+      stdout: bunStdio,
+      stderr: bunStdio,
+    });
+
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => proc.kill?.("SIGTERM"),
+      () => proc.kill?.("SIGKILL"),
+    );
+
+    try {
+      const [code, stdout, stderr] = await Promise.all([
+        proc.exited,
+        capture && proc.stdout ? readStreamToString(proc.stdout) : Promise.resolve(undefined),
+        capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
+      ]);
+
+      if (timeout.hasTimedOut()) {
+        return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+      }
+
+      return { success: code === 0, code, stdout, stderr };
+    } finally {
+      timeout.clear();
+    }
+  }
+
+  if (!runtimeProcess) return { success: false, code: 1 };
+  const process = runtimeProcess;
+
+  const { spawn } = await dynamicImport<typeof import("node:child_process")>("node:child_process");
+
+  const nodeStdio: [
+    "ignore" | "inherit" | "pipe",
+    "ignore" | "inherit" | "pipe",
+    "ignore" | "inherit" | "pipe",
+  ] = inherit
+    ? ["inherit", "inherit", "inherit"]
+    : capture
+    ? ["ignore", "pipe", "pipe"]
+    : ["ignore", "ignore", "ignore"];
+
+  return await new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      cwd: cmdCwd,
+      env: cmdEnv ? { ...process.env, ...cmdEnv } : undefined,
+      stdio: nodeStdio,
+      shell,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    const decoder = new TextDecoder();
+    const timeout = createProcessTimeout(
+      effectiveTimeoutMs,
+      () => child.kill("SIGTERM"),
+      () => child.kill("SIGKILL"),
+    );
+
+    if (capture) {
+      child.stdout?.on("data", (data: Uint8Array) => {
+        stdout += decoder.decode(data);
+      });
+      child.stderr?.on("data", (data: Uint8Array) => {
+        stderr += decoder.decode(data);
+      });
+    }
+
+    child.on("close", (code) => {
+      timeout.clear();
+
+      if (timeout.hasTimedOut()) {
+        resolve(
+          createTimeoutResult(
+            effectiveTimeoutMs ?? 0,
+            capture ? stdout : undefined,
+            capture ? stderr : undefined,
+          ),
+        );
+        return;
+      }
+
+      resolve({
+        success: code === 0,
+        code: code ?? 1,
+        stdout: capture ? stdout : undefined,
+        stderr: capture ? stderr : undefined,
+      });
+    });
+
+    child.on("error", () => {
+      timeout.clear();
+      resolve({ success: false, code: 1 });
+    });
+  });
+}

package/src/src/platform/compat/process/env.ts

@@ -0,0 +1,227 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { isDeno as IS_DENO } from "../runtime.js";
+import { runtimeProcess } from "./runtime-process.js";
+
+type EnvOverlayValue = string | null;
+type EnvOverlayStore = Map<string, EnvOverlayValue>;
+
+export type EnvOverlayStorage = {
+  getStore: () => unknown;
+  run?: <T>(store: unknown, fn: () => T) => T;
+  enterWith?: (store: unknown) => void;
+};
+
+function getEnvOverlayStore(): EnvOverlayStore | null {
+  const storage = getEnvOverlayStorage();
+  const store = storage?.getStore();
+  return store instanceof Map ? store as EnvOverlayStore : null;
+}
+
+function getOverlayEnvValue(
+  store: EnvOverlayStore | null,
+  key: string,
+): { hasValue: boolean; value: string | undefined } {
+  if (!store?.has(key)) {
+    return { hasValue: false, value: undefined };
+  }
+
+  const value = store.get(key);
+  return { hasValue: true, value: value ?? undefined };
+}
+
+export function env(): Record<string, string> {
+  const base = IS_DENO
+    ? dntShim.Deno.env.toObject()
+    : runtimeProcess
+    ? { ...runtimeProcess.env } as Record<string, string>
+    : {};
+
+  const overlay = getEnvOverlayStore();
+  if (!overlay) return base;
+
+  for (const [key, value] of overlay.entries()) {
+    if (value === null) {
+      delete base[key];
+      continue;
+    }
+    base[key] = value;
+  }
+
+  return base;
+}
+
+/**
+ * Read a host-level environment variable without consulting any project env overlay.
+ * Use this for framework-owned runtime configuration that should not be shadowed by tenant env.
+ */
+export function getHostEnv(key: string): string | undefined {
+  const overlayResult = getOverlayEnvValue(getEnvOverlayStore(), key);
+  if (overlayResult.hasValue) {
+    return overlayResult.value;
+  }
+
+  if (IS_DENO) return dntShim.Deno.env.get(key);
+  if (runtimeProcess) return runtimeProcess.env[key];
+  return undefined;
+}
+
+// Lazy-loaded references to project-env/storage.ts functions.
+// Uses globalThis to avoid circular imports (process compat is low-level, project-env is high-level).
+// IMPORTANT: Only cache when the real getter is found. If storage.ts hasn't loaded yet,
+// re-check globalThis on every call to avoid permanently caching the fallback.
+let _getProjectEnv: ((key: string) => string | undefined) | null = null;
+let _isProjectEnvActive: (() => boolean) | null = null;
+
+function getProjectEnvSafe(key: string): string | undefined {
+  if (_getProjectEnv === null) {
+    const mod = (dntShim.dntGlobalThis as Record<string, unknown>).__vfProjectEnvGetter as
+      | ((key: string) => string | undefined)
+      | undefined;
+    if (mod) {
+      _getProjectEnv = mod;
+    } else {
+      return undefined;
+    }
+  }
+  return _getProjectEnv(key);
+}
+
+function isProjectEnvActiveSafe(): boolean {
+  if (_isProjectEnvActive === null) {
+    const mod = (dntShim.dntGlobalThis as Record<string, unknown>).__vfProjectEnvActiveChecker as
+      | (() => boolean)
+      | undefined;
+    if (mod) {
+      _isProjectEnvActive = mod;
+    } else {
+      return false;
+    }
+  }
+  return _isProjectEnvActive();
+}
+
+export function getEnv(key: string): string | undefined {
+  // Check per-request project env overlay first (AsyncLocalStorage)
+  const projectValue = getProjectEnvSafe(key);
+  if (projectValue !== undefined) return projectValue;
+
+  // When a project env overlay is active (remote project request), do NOT
+  // fall through to host process env. This prevents remote projects from
+  // reading host-level secrets like AWS_SECRET_ACCESS_KEY, DATABASE_URL, etc.
+  if (isProjectEnvActiveSafe()) return undefined;
+
+  return getHostEnv(key);
+}
+
+const DEFAULT_ENV_TRUE_VALUES = ["1", "true", "yes"] as const;
+const DEFAULT_ENV_FALSE_VALUES = ["0", "false", "no"] as const;
+
+export interface EnvBooleanOptions {
+  trueValues?: readonly string[];
+  falseValues?: readonly string[];
+  trim?: boolean;
+  caseSensitive?: boolean;
+}
+
+function normalizeEnvToken(
+  value: string,
+  options: { trim: boolean; caseSensitive: boolean },
+): string {
+  const normalized = options.trim ? value.trim() : value;
+  return options.caseSensitive ? normalized : normalized.toLowerCase();
+}
+
+export function getEnvString(key: string): string | undefined;
+export function getEnvString(key: string, fallback: string): string;
+export function getEnvString(key: string, fallback?: string): string | undefined {
+  const value = getEnv(key);
+  if (value === undefined) return fallback;
+  return value;
+}
+
+export function getEnvNumber(key: string): number | undefined;
+export function getEnvNumber(key: string, fallback: number): number;
+export function getEnvNumber(key: string, fallback?: number): number | undefined {
+  const value = getEnvString(key);
+  if (value === undefined) return fallback;
+
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) return fallback ?? Number.NaN;
+  return parsed;
+}
+
+export function getEnvBoolean(
+  key: string,
+  fallback = false,
+  options: EnvBooleanOptions = {},
+): boolean {
+  const value = getEnvString(key);
+  if (value === undefined) return fallback;
+
+  const trim = options.trim ?? true;
+  const caseSensitive = options.caseSensitive ?? false;
+  const normalized = normalizeEnvToken(value, { trim, caseSensitive });
+
+  const trueValues = options.trueValues ?? DEFAULT_ENV_TRUE_VALUES;
+  for (const trueValue of trueValues) {
+    if (normalized === normalizeEnvToken(trueValue, { trim, caseSensitive })) return true;
+  }
+
+  const falseValues = options.falseValues ?? DEFAULT_ENV_FALSE_VALUES;
+  for (const falseValue of falseValues) {
+    if (normalized === normalizeEnvToken(falseValue, { trim, caseSensitive })) return false;
+  }
+
+  return fallback;
+}
+
+export function setEnv(key: string, value: string): void {
+  const overlay = getEnvOverlayStore();
+  if (overlay) {
+    overlay.set(key, value);
+    return;
+  }
+
+  if (IS_DENO) {
+    dntShim.Deno.env.set(key, value);
+    return;
+  }
+  if (runtimeProcess) {
+    runtimeProcess.env[key] = value;
+    return;
+  }
+  throw new Error("setEnv() is not supported in this runtime");
+}
+
+export function deleteEnv(key: string): void {
+  const overlay = getEnvOverlayStore();
+  if (overlay) {
+    overlay.set(key, null);
+    return;
+  }
+
+  if (IS_DENO) {
+    dntShim.Deno.env.delete(key);
+    return;
+  }
+  if (runtimeProcess) {
+    delete runtimeProcess.env[key];
+    return;
+  }
+  throw new Error("deleteEnv() is not supported in this runtime");
+}
+
+/**
+ * Get an AsyncLocalStorage-based env overlay storage if installed.
+ * This enables per-async-context env isolation (e.g., in tests).
+ */
+export function getEnvOverlayStorage(): EnvOverlayStorage | null {
+  const globalAny = dntShim.dntGlobalThis as Record<string, unknown>;
+  const overlay =
+    (globalAny["__vfTestDenoEnvOverlay"] as { storage?: EnvOverlayStorage } | undefined) ??
+      (globalAny["__vfTestEnvOverlay"] as { storage?: EnvOverlayStorage } | undefined);
+
+  const storage = overlay?.storage;
+  if (!storage || typeof storage.getStore !== "function") return null;
+  return storage;
+}