opencode-secrets-obfuscation 0.1.0 → 0.1.1

package/tests/support/child-process.ts

@@ -1,235 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process"
-import { createHash } from "node:crypto"
-import { lstat, readFile } from "node:fs/promises"
-import { isAbsolute } from "node:path"
-
-export type ChildErrorCode =
-  | "INVALID_OPTIONS"
-  | "EXECUTABLE_MISMATCH"
-  | "STARTUP_TIMEOUT"
-  | "TIMEOUT"
-  | "CANCELLED"
-  | "OUTPUT_LIMIT"
-  | "SPAWN_FAILED"
-  | "EXIT_FAILED"
-  | "TEARDOWN_FAILED"
-
-export class ChildProcessError extends Error {
-  readonly code: ChildErrorCode
-
-  constructor(code: ChildErrorCode) {
-    super(code)
-    this.name = "ChildProcessError"
-    this.code = code
-  }
-}
-
-export interface ChildOptions {
-  readonly executable: string
-  readonly expectedExecutableSha256: string
-  readonly args: readonly string[]
-  readonly cwd: string
-  readonly env: Readonly<Record<string, string>>
-  readonly allowedEnv: readonly string[]
-  readonly startupTimeoutMs: number
-  readonly overallTimeoutMs: number
-  readonly stdoutLimitBytes?: number
-  readonly stderrLimitBytes?: number
-  readonly signal?: AbortSignal
-}
-
-export interface ChildResult {
-  readonly exitCode: number
-  readonly signal: NodeJS.Signals | null
-  readonly stdout: string
-  readonly stderr: string
-  readonly cwd: string
-}
-
-const DEFAULT_OUTPUT_LIMIT = 1024 * 1024
-const TERM_GRACE_MS = 100
-const TEARDOWN_LIMIT_MS = 1_000
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function isValid(value: unknown): value is ChildOptions {
-  if (!isObject(value)) return false
-  const options = value as Partial<ChildOptions>
-  if (typeof options.executable !== "string" || !isAbsolute(options.executable)) return false
-  if (typeof options.expectedExecutableSha256 !== "string" || !/^[0-9a-f]{64}$/i.test(options.expectedExecutableSha256)) return false
-  if (!Array.isArray(options.args) || options.args.some((arg) => typeof arg !== "string")) return false
-  if (typeof options.cwd !== "string" || !isAbsolute(options.cwd)) return false
-  if (!isObject(options.env) || Object.values(options.env).some((item) => typeof item !== "string")) return false
-  if (!Array.isArray(options.allowedEnv) || options.allowedEnv.some((key) => typeof key !== "string" || key.length === 0 || key.includes("="))) return false
-  const fold = (key: string): string => process.platform === "win32" ? key.toUpperCase() : key
-  const allowed = new Set(options.allowedEnv.map(fold))
-  if (allowed.size !== options.allowedEnv.length) return false
-  if (Object.keys(options.env).some((key) => !allowed.has(fold(key)) || key.includes("=") || key.length === 0)) return false
-  const startup = options.startupTimeoutMs
-  const overall = options.overallTimeoutMs
-  if (typeof startup !== "number" || !Number.isSafeInteger(startup) || startup <= 0) return false
-  if (typeof overall !== "number" || !Number.isSafeInteger(overall) || overall <= 0) return false
-  if (options.stdoutLimitBytes !== undefined && (!Number.isSafeInteger(options.stdoutLimitBytes) || options.stdoutLimitBytes < 0)) return false
-  if (options.stderrLimitBytes !== undefined && (!Number.isSafeInteger(options.stderrLimitBytes) || options.stderrLimitBytes < 0)) return false
-  return options.signal === undefined || options.signal instanceof AbortSignal
-}
-
-async function executableMatches(options: ChildOptions): Promise<boolean> {
-  try {
-    const stat = await lstat(options.executable)
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) return false
-    const digest = createHash("sha256").update(await readFile(options.executable)).digest("hex")
-    return digest === options.expectedExecutableSha256.toLowerCase()
-  } catch {
-    return false
-  }
-}
-
-export async function runChild(value: unknown): Promise<ChildResult> {
-  if (!isValid(value)) throw new ChildProcessError("INVALID_OPTIONS")
-  const options = value
-  if (options.signal?.aborted) throw new ChildProcessError("CANCELLED")
-  if (!(await executableMatches(options))) throw new ChildProcessError("EXECUTABLE_MISMATCH")
-  if (options.signal?.aborted) throw new ChildProcessError("CANCELLED")
-
-  const env = Object.create(null) as Record<string, string>
-  for (const key of options.allowedEnv) {
-    const actual = Object.keys(options.env).find((candidate) => process.platform === "win32" ? candidate.toUpperCase() === key.toUpperCase() : candidate === key)
-    if (actual !== undefined) env[key] = options.env[actual]!
-  }
-  const stdoutLimit = options.stdoutLimitBytes ?? DEFAULT_OUTPUT_LIMIT
-  const stderrLimit = options.stderrLimitBytes ?? DEFAULT_OUTPUT_LIMIT
-
-  return new Promise((resolve, reject) => {
-    let child: ChildProcess
-    try {
-      child = spawn(options.executable, [...options.args], {
-        cwd: options.cwd,
-        env,
-        shell: false,
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"],
-      })
-    } catch {
-      reject(new ChildProcessError("SPAWN_FAILED"))
-      return
-    }
-
-    let promiseSettled = false
-    let terminating = false
-    let spawned = false
-    let childClosed = false
-    let stdoutClosed = false
-    let stderrClosed = false
-    let stdoutBytes = 0
-    let stderrBytes = 0
-    const stdoutChunks: Buffer[] = []
-    const stderrChunks: Buffer[] = []
-    let failure: ChildErrorCode | undefined
-    let startupTimer: NodeJS.Timeout | undefined
-    let overallTimer: NodeJS.Timeout | undefined
-    let escalationTimer: NodeJS.Timeout | undefined
-    let teardownTimer: NodeJS.Timeout | undefined
-
-    const clearTimers = (): void => {
-      if (startupTimer) clearTimeout(startupTimer)
-      if (overallTimer) clearTimeout(overallTimer)
-      if (escalationTimer) clearTimeout(escalationTimer)
-      if (teardownTimer) clearTimeout(teardownTimer)
-    }
-    const removeAbort = (): void => options.signal?.removeEventListener("abort", onAbort)
-    const rejectAfterClose = (): void => {
-      if (promiseSettled || !failure || !childClosed) return
-      promiseSettled = true
-      clearTimers()
-      removeAbort()
-      reject(new ChildProcessError(failure))
-    }
-    const forceAndWait = (): void => {
-      if (promiseSettled || !terminating) return
-      try {
-        if (child.pid !== undefined) child.kill("SIGKILL")
-      } catch {
-        // The bounded teardown timer below remains the authoritative outcome.
-      }
-      teardownTimer = setTimeout(() => {
-        if (!promiseSettled) {
-          promiseSettled = true
-          clearTimers()
-          removeAbort()
-          reject(new ChildProcessError("TEARDOWN_FAILED"))
-        }
-      }, TEARDOWN_LIMIT_MS)
-    }
-    const beginFailure = (code: ChildErrorCode): void => {
-      if (promiseSettled || terminating) return
-      failure = code
-      terminating = true
-      clearTimers()
-      removeAbort()
-      // This is the PID returned by this spawn call. No process discovery or
-      // tree-wide signal is implied; a real host needs a Job Object/group.
-      try {
-        if (child.pid !== undefined) child.kill()
-      } catch {
-        // Escalation and the bounded failure path decide whether teardown was proven.
-      }
-      escalationTimer = setTimeout(forceAndWait, TERM_GRACE_MS)
-      rejectAfterClose()
-    }
-    const onAbort = (): void => beginFailure("CANCELLED")
-
-    // Register cancellation immediately before the synchronous spawn call. The
-    // pre-aborted checks above handle the no-spawn case; this listener owns the
-    // cancellation race after a child has been successfully created.
-    if (options.signal) options.signal.addEventListener("abort", onAbort, { once: true })
-    if (options.signal?.aborted) {
-      removeAbort()
-      reject(new ChildProcessError("CANCELLED"))
-      return
-    }
-
-    startupTimer = setTimeout(() => beginFailure("STARTUP_TIMEOUT"), options.startupTimeoutMs)
-    overallTimer = setTimeout(() => beginFailure("TIMEOUT"), options.overallTimeoutMs)
-    child.once("spawn", () => {
-      spawned = true
-      if (startupTimer) clearTimeout(startupTimer)
-    })
-    child.once("error", () => beginFailure(spawned ? "EXIT_FAILED" : "SPAWN_FAILED"))
-    child.stdout?.once("close", () => { stdoutClosed = true; rejectAfterClose() })
-    child.stderr?.once("close", () => { stderrClosed = true; rejectAfterClose() })
-    child.stdout?.on("data", (chunk: Buffer) => {
-      if (terminating) return
-      stdoutBytes += chunk.byteLength
-      if (stdoutBytes > stdoutLimit) {
-        beginFailure("OUTPUT_LIMIT")
-        return
-      }
-      stdoutChunks.push(chunk)
-    })
-    child.stderr?.on("data", (chunk: Buffer) => {
-      if (terminating) return
-      stderrBytes += chunk.byteLength
-      if (stderrBytes > stderrLimit) {
-        beginFailure("OUTPUT_LIMIT")
-        return
-      }
-      stderrChunks.push(chunk)
-    })
-    child.once("close", (exitCode, signal) => {
-      childClosed = true
-      if (failure) {
-        rejectAfterClose()
-      } else if (exitCode === null) {
-        beginFailure("EXIT_FAILED")
-      } else {
-        promiseSettled = true
-        clearTimers()
-        removeAbort()
-        resolve({ exitCode, signal, stdout: Buffer.concat(stdoutChunks).toString("utf8"), stderr: Buffer.concat(stderrChunks).toString("utf8"), cwd: options.cwd })
-      }
-    })
-  })
-}

package/tests/support/host-api.ts

@@ -1,123 +0,0 @@
-import { request } from "node:http"
-import { isAbsolute, relative, resolve, sep } from "node:path"
-
-const MAX_BODY = 64 * 1024
-const MAX_HEADERS = 16 * 1024
-const DEFAULT_TIMEOUT = 2_000
-
-export interface HostInfo {
-  readonly version: string
-  readonly pid: number
-  readonly urls: readonly string[]
-  readonly paths: Readonly<{ readonly tmp: string }>
-}
-
-interface HostApiInput {
-  readonly origin: string
-  readonly password: string
-  readonly expectedVersion: string
-  readonly expectedPID?: number
-  readonly expectedTmpRoot: string
-  readonly timeoutMs?: number
-}
-
-function invalid(): never { throw new Error("HOST_API_INVALID") }
-
-function fields(value: unknown, required: readonly string[], optional: readonly string[] = []): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) invalid()
-  const prototype = Object.getPrototypeOf(value)
-  if (prototype !== Object.prototype && prototype !== null) invalid()
-  const keys = Reflect.ownKeys(value)
-  if (keys.some((key) => typeof key !== "string" || (!required.includes(key) && !optional.includes(key)))) invalid()
-  const result: Record<string, unknown> = Object.create(null)
-  for (const key of keys) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key)
-    if (!descriptor || !("value" in descriptor)) invalid()
-    result[key as string] = descriptor.value
-  }
-  if (required.some((key) => !Object.hasOwn(result, key))) invalid()
-  return result
-}
-
-function requiredFields(value: unknown, required: readonly string[]): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) invalid()
-  const prototype = Object.getPrototypeOf(value)
-  if (prototype !== Object.prototype && prototype !== null) invalid()
-  const result: Record<string, unknown> = Object.create(null)
-  for (const key of required) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key)
-    if (!descriptor || !("value" in descriptor)) invalid()
-    result[key] = descriptor.value
-  }
-  return result
-}
-
-function parseInput(value: unknown): HostApiInput {
-  try {
-    const input = fields(value, ["origin", "password", "expectedVersion", "expectedTmpRoot"], ["expectedPID", "timeoutMs"])
-    if (typeof input.origin !== "string" || !/^http:\/\/127\.0\.0\.1:\d+$/.test(input.origin)) invalid()
-    const url = new URL(input.origin)
-    if (url.origin !== input.origin || url.pathname !== "/" || url.search || url.hash || !url.port) invalid()
-    if (typeof input.password !== "string" || !/^[a-f0-9]{64}$/.test(input.password)) invalid()
-    if (typeof input.expectedVersion !== "string" || input.expectedVersion.length === 0 || input.expectedVersion.length > 128) invalid()
-    if (typeof input.expectedTmpRoot !== "string" || !isAbsolute(input.expectedTmpRoot) || input.expectedTmpRoot.length > 4_096) invalid()
-    if (input.expectedPID !== undefined && (typeof input.expectedPID !== "number" || !Number.isSafeInteger(input.expectedPID) || input.expectedPID < 0)) invalid()
-    if (input.timeoutMs !== undefined && (typeof input.timeoutMs !== "number" || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 10_000)) invalid()
-    return input as unknown as HostApiInput
-  } catch (error) {
-    if (error instanceof Error && error.message === "HOST_API_INVALID") throw error
-    throw new Error("HOST_API_INVALID")
-  }
-}
-
-function contained(root: string, value: string): boolean {
-  const parent = resolve(root)
-  const child = resolve(value)
-  const rest = relative(parent, child)
-  return rest === "" || (rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest))
-}
-
-function decode(body: string, input: HostApiInput): HostInfo {
-  let value: unknown
-  try { value = JSON.parse(body) } catch { throw new Error("HOST_API_SCHEMA") }
-  let data: Record<string, unknown>
-  try { data = requiredFields(value, ["version", "pid", "urls", "paths"]) } catch { throw new Error("HOST_API_SCHEMA") }
-  if (typeof data.version !== "string" || data.version !== input.expectedVersion) throw new Error("HOST_API_VERSION")
-  if (typeof data.pid !== "number" || !Number.isSafeInteger(data.pid) || data.pid < 0) throw new Error("HOST_API_SCHEMA")
-  if (input.expectedPID !== undefined && data.pid !== input.expectedPID) throw new Error("HOST_API_PID")
-  if (!Array.isArray(data.urls) || data.urls.some((url) => typeof url !== "string")) throw new Error("HOST_API_SCHEMA")
-  const urls = data.urls as string[]
-  for (const advertised of urls) {
-    try { if (new URL(advertised).origin !== input.origin) throw new Error() } catch { throw new Error("HOST_API_URL") }
-  }
-  let paths: Record<string, unknown>
-  try { paths = requiredFields(data.paths, ["tmp"]) } catch { throw new Error("HOST_API_SCHEMA") }
-  if (typeof paths.tmp !== "string" || !isAbsolute(paths.tmp) || !contained(input.expectedTmpRoot, paths.tmp)) throw new Error("HOST_API_TMP_ROOT")
-  return Object.freeze({ version: data.version, pid: data.pid, urls: Object.freeze([...urls]), paths: Object.freeze({ tmp: paths.tmp }) })
-}
-
-export function requestHostInfo(value: unknown): Promise<HostInfo> {
-  let input: HostApiInput
-  try { input = parseInput(value) } catch (error) { return Promise.reject(error instanceof Error && error.message === "HOST_API_INVALID" ? error : new Error("HOST_API_INVALID")) }
-  return new Promise((resolveResult, reject) => {
-    let settled = false
-    const finish = (error?: Error, result?: HostInfo) => {
-      if (settled) return
-      settled = true
-      if (error) reject(error)
-      else resolveResult(result as HostInfo)
-    }
-    const timer = setTimeout(() => { requestHandle.destroy(); finish(new Error("HOST_API_TIMEOUT")) }, input.timeoutMs ?? DEFAULT_TIMEOUT)
-    const requestHandle = request({ hostname: "127.0.0.1", port: Number(new URL(input.origin).port), path: "/api/info", method: "GET", auth: `opencode:${input.password}`, maxHeaderSize: MAX_HEADERS }, (response) => {
-      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400) { response.destroy(); clearTimeout(timer); finish(new Error("HOST_API_REDIRECT")); return }
-      if (response.statusCode !== 200) { response.destroy(); clearTimeout(timer); finish(new Error("HOST_API_STATUS")); return }
-      let size = 0
-      const chunks: Buffer[] = []
-      response.on("data", (chunk: Buffer) => { size += chunk.length; if (size > MAX_BODY) { response.destroy(); clearTimeout(timer); finish(new Error("HOST_API_BODY")); } else chunks.push(chunk) })
-      response.on("end", () => { clearTimeout(timer); try { finish(undefined, decode(Buffer.concat(chunks).toString("utf8"), input)) } catch (error) { finish(error instanceof Error ? error : new Error("HOST_API_SCHEMA")) } })
-      response.on("error", () => { clearTimeout(timer); finish(new Error("HOST_API_TRANSPORT")) })
-    })
-    requestHandle.on("error", () => { clearTimeout(timer); finish(new Error("HOST_API_TRANSPORT")) })
-    requestHandle.end()
-  })
-}

package/tests/support/opencode-environment.ts

@@ -1,239 +0,0 @@
-import { isAbsolute, join, relative, resolve, sep } from "node:path"
-
-export interface TrustedOsEnvironment {
-  readonly userProfile: string
-  readonly home: string
-  readonly programData: string
-  readonly temp: string
-  readonly tmp: string
-  readonly path: string
-  readonly systemRoot: string
-  readonly comspec: string
-  readonly pathext: string
-}
-
-export interface OpenCodeEnvironmentInput {
-  readonly root: string
-  /** Generate 32 random bytes per run; never source this from user credentials. */
-  readonly password: string
-  readonly trustedOs: TrustedOsEnvironment
-  readonly configContent?: unknown
-  /**
-   * Host-neutral config keys (plugins, providers, ...) merged into
-   * OPENCODE_CONFIG_CONTENT. Deep-validated without evaluating accessors;
-   * snapshots/warming/update stay locked to the boot defaults.
-   */
-  readonly sandboxConfig?: unknown
-}
-
-export interface OpenCodeEnvironment {
-  readonly root: string
-  readonly cwd: string
-  readonly paths: Readonly<{
-    readonly data: string
-    readonly cache: string
-    readonly config: string
-    readonly state: string
-    readonly temp: string
-    readonly database: string
-  }>
-  readonly allowedEnv: readonly string[]
-  readonly env: Readonly<Record<string, string>>
-}
-
-const DEFAULT_CONFIG = {
-  snapshots: false,
-  warming: false,
-  update: "disable",
-} as const
-
-const ALLOWED_ENV = [
-  "USERPROFILE",
-  "HOME",
-  "ProgramData",
-  "PATH",
-  "SystemRoot",
-  "ComSpec",
-  "PATHEXT",
-  "TEMP",
-  "TMP",
-  "XDG_DATA_HOME",
-  "XDG_CACHE_HOME",
-  "XDG_CONFIG_HOME",
-  "XDG_STATE_HOME",
-  "OPENCODE_CONFIG_DIR",
-  "OPENCODE_CONFIG_PROJECT_DISABLE",
-  "OPENCODE_CONFIG_CONTENT",
-  "OPENCODE_DB",
-  "OPENCODE_PASSWORD",
-  "OPENCODE_DISABLE_MODELS_FETCH",
-  "OPENCODE_DISABLE_AUTOUPDATE",
-  "OPENCODE_DISABLE_FILEWATCHER",
-  "OPENCODE_DISABLE_PROJECT_CONFIG",
-] as const
-
-function beneath(root: string, value: string): boolean {
-  if (!isAbsolute(value)) return false
-  const child = resolve(value)
-  const parent = resolve(root)
-  const rest = relative(parent, child)
-  return rest === "" || (rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest))
-}
-
-function safeEnvironmentValue(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0 && value.length <= 32_768 && !/[\0\r\n]/.test(value)
-}
-
-function dataFields(value: unknown, required: readonly string[], optional: readonly string[] = []): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) throw 0
-  const prototype = Object.getPrototypeOf(value)
-  if (prototype !== Object.prototype && prototype !== null) throw 0
-  const keys = Reflect.ownKeys(value)
-  if (keys.length > required.length + optional.length) throw 0
-  const result: Record<string, unknown> = Object.create(null)
-  for (const key of keys) {
-    if (typeof key !== "string" || (!required.includes(key) && !optional.includes(key))) throw 0
-    const descriptor = Object.getOwnPropertyDescriptor(value, key)
-    if (!descriptor || !("value" in descriptor)) throw 0
-    result[key] = descriptor.value
-  }
-  if (required.some((key) => !Object.hasOwn(result, key))) throw 0
-  return result
-}
-
-function lockedConfig(value: unknown): Readonly<Record<string, boolean | string>> {
-  if (value === undefined) return DEFAULT_CONFIG
-  const values = dataFields(value, [], ["snapshots", "warming", "update"])
-  for (const [key, actual] of Object.entries(values)) {
-    const expected = DEFAULT_CONFIG[key as keyof typeof DEFAULT_CONFIG]
-    if (actual !== expected) throw 0
-  }
-  return Object.freeze({ ...DEFAULT_CONFIG })
-}
-
-const SANDBOX_MAX_DEPTH = 16
-const SANDBOX_MAX_NODES = 8_192
-const SANDBOX_MAX_STRING = 32_768
-
-/**
- * Deep-clones a sandbox config through data descriptors only: accessors are
- * never evaluated, cycles, sparse holes, non-finite numbers, oversized strings
- * and non-plain containers are rejected, and locked boot keys may only carry
- * their locked value. The clone cannot observe later caller mutation, so the
- * final JSON.stringify runs on inert data.
- */
-function sandboxConfig(value: unknown): Record<string, unknown> | undefined {
-  if (value === undefined) return undefined
-  if (typeof value !== "object" || value === null || Array.isArray(value)) throw 0
-  const rootPrototype = Object.getPrototypeOf(value)
-  if (rootPrototype !== Object.prototype && rootPrototype !== null) throw 0
-  let nodes = 0
-  const seen = new WeakSet<object>()
-  const walk = (input: unknown, depth: number): unknown => {
-    nodes += 1
-    if (nodes > SANDBOX_MAX_NODES || depth > SANDBOX_MAX_DEPTH) throw 0
-    if (input === null || typeof input === "boolean") return input
-    if (typeof input === "number") {
-      if (!Number.isFinite(input)) throw 0
-      return input
-    }
-    if (typeof input === "string") {
-      if (input.length > SANDBOX_MAX_STRING) throw 0
-      return input
-    }
-    if (typeof input !== "object") throw 0
-    if (seen.has(input)) throw 0
-    seen.add(input)
-    if (Array.isArray(input)) {
-      const result: unknown[] = []
-      for (let index = 0; index < input.length; index += 1) {
-        const descriptor = Object.getOwnPropertyDescriptor(input, String(index))
-        if (!descriptor || !("value" in descriptor)) throw 0
-        result.push(walk(descriptor.value, depth + 1))
-      }
-      return result
-    }
-    const prototype = Object.getPrototypeOf(input)
-    if (prototype !== Object.prototype && prototype !== null) throw 0
-    const result: Record<string, unknown> = {}
-    for (const key of Reflect.ownKeys(input)) {
-      if (typeof key !== "string") throw 0
-      const descriptor = Object.getOwnPropertyDescriptor(input, key)
-      if (!descriptor || !("value" in descriptor)) throw 0
-      const cloned = walk(descriptor.value, depth + 1)
-      if (depth === 0) {
-        const expected = DEFAULT_CONFIG[key as keyof typeof DEFAULT_CONFIG]
-        if (expected !== undefined && cloned !== expected) throw 0
-      }
-      result[key] = cloned
-    }
-    return result
-  }
-  return walk(value, 0) as Record<string, unknown>
-}
-
-export function buildOpenCodeEnvironment(value: unknown): OpenCodeEnvironment {
-  try {
-    const input = dataFields(value, ["root", "trustedOs", "password"], ["configContent", "sandboxConfig"])
-    if (!safeEnvironmentValue(input.root)) throw 0
-    if (typeof input.password !== "string" || !/^[a-f0-9]{64}$/.test(input.password)) throw 0
-    const trusted = dataFields(input.trustedOs, ["userProfile", "home", "programData", "temp", "tmp", "path", "systemRoot", "comspec", "pathext"])
-    if (Object.values(trusted).some((field) => !safeEnvironmentValue(field))) throw 0
-    if (!isAbsolute(trusted.systemRoot as string) || !isAbsolute(trusted.comspec as string)) throw 0
-    return buildValidated({ ...input, trustedOs: trusted } as unknown as OpenCodeEnvironmentInput)
-  } catch {
-    throw new Error("OPENCODE_ENVIRONMENT_INVALID")
-  }
-}
-
-function buildValidated(input: OpenCodeEnvironmentInput): OpenCodeEnvironment {
-  if (!isAbsolute(input.root)) throw new Error("private root must be absolute")
-  const root = resolve(input.root)
-  for (const value of Object.values(input.trustedOs)) {
-    if (!safeEnvironmentValue(value)) throw new Error("invalid trusted OS environment")
-  }
-  const paths = {
-    data: join(root, "data"),
-    cache: join(root, "cache"),
-    config: join(root, "config", "opencode"),
-    state: join(root, "state"),
-    temp: join(root, "temp"),
-    database: join(root, "data", "opencode.db"),
-  }
-  for (const value of Object.values(paths)) {
-    if (!beneath(root, value)) throw new Error("OpenCode path escapes private root")
-  }
-  for (const value of [input.trustedOs.userProfile, input.trustedOs.home, input.trustedOs.programData, input.trustedOs.temp, input.trustedOs.tmp]) {
-    if (!beneath(root, value)) throw new Error("trusted OS path escapes private root")
-  }
-  const config = { ...sandboxConfig(input.sandboxConfig), ...lockedConfig(input.configContent) }
-  const env: Record<string, string> = {
-    USERPROFILE: input.trustedOs.userProfile,
-    HOME: input.trustedOs.home,
-    ProgramData: input.trustedOs.programData,
-    PATH: input.trustedOs.path,
-    SystemRoot: input.trustedOs.systemRoot,
-    ComSpec: input.trustedOs.comspec,
-    PATHEXT: input.trustedOs.pathext,
-    TEMP: input.trustedOs.temp,
-    TMP: input.trustedOs.tmp,
-    XDG_DATA_HOME: paths.data,
-    XDG_CACHE_HOME: paths.cache,
-    XDG_CONFIG_HOME: join(root, "config"),
-    XDG_STATE_HOME: paths.state,
-    OPENCODE_CONFIG_DIR: paths.config,
-    OPENCODE_CONFIG_PROJECT_DISABLE: "1",
-    OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
-    OPENCODE_DB: paths.database,
-    OPENCODE_PASSWORD: input.password,
-    // Names verified against the pinned opencode binary's own strings.
-    OPENCODE_DISABLE_MODELS_FETCH: "1",
-    OPENCODE_DISABLE_AUTOUPDATE: "1",
-    OPENCODE_DISABLE_FILEWATCHER: "1",
-    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
-  }
-  const frozenPaths = Object.freeze(paths)
-  const allowedEnv = Object.freeze([...ALLOWED_ENV])
-  const frozenEnv = Object.freeze({ ...env })
-  return Object.freeze({ root, cwd: join(root, "cwd"), paths: frozenPaths, allowedEnv, env: frozenEnv })
-}