@happy-creative/iroder 1.0.0

package/src/file/watcher.ts

@@ -0,0 +1,171 @@
+import { Cause, Effect, Layer, Scope, ServiceMap } from "effect"
+// @ts-ignore
+import { createWrapper } from "@parcel/watcher/wrapper"
+import type ParcelWatcher from "@parcel/watcher"
+import { readdir } from "fs/promises"
+import path from "path"
+import z from "zod"
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { Flag } from "@/flag/flag"
+import { Git } from "@/git"
+import { Instance } from "@/project/instance"
+import { lazy } from "@/util/lazy"
+import { Config } from "../config/config"
+import { FileIgnore } from "./ignore"
+import { Protected } from "./protected"
+import { Log } from "../util/log"
+
+declare const IRODER_LIBC: string | undefined
+
+export namespace FileWatcher {
+  const log = Log.create({ service: "file.watcher" })
+  const SUBSCRIBE_TIMEOUT_MS = 10_000
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "file.watcher.updated",
+      z.object({
+        file: z.string(),
+        event: z.union([z.literal("add"), z.literal("change"), z.literal("unlink")]),
+      }),
+    ),
+  }
+
+  const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
+    try {
+      const binding = require(
+        `@parcel/watcher-${process.platform}-${process.arch}${process.platform === "linux" ? `-${IRODER_LIBC || "glibc"}` : ""}`,
+      )
+      return createWrapper(binding) as typeof import("@parcel/watcher")
+    } catch (error) {
+      log.error("failed to load watcher binding", { error })
+      return
+    }
+  })
+
+  function getBackend() {
+    if (process.platform === "win32") return "windows"
+    if (process.platform === "darwin") return "fs-events"
+    if (process.platform === "linux") return "inotify"
+  }
+
+  function protecteds(dir: string) {
+    return Protected.paths().filter((item) => {
+      const rel = path.relative(dir, item)
+      return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
+    })
+  }
+
+  export const hasNativeBinding = () => !!watcher()
+
+  export interface Interface {
+    readonly init: () => Effect.Effect<void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@iroder/FileWatcher") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const config = yield* Config.Service
+
+      const state = yield* InstanceState.make(
+        Effect.fn("FileWatcher.state")(
+          function* () {
+            if (yield* Flag.IRODER_EXPERIMENTAL_DISABLE_FILEWATCHER) return
+
+            log.info("init", { directory: Instance.directory })
+
+            const backend = getBackend()
+            if (!backend) {
+              log.error("watcher backend not supported", { directory: Instance.directory, platform: process.platform })
+              return
+            }
+
+            const w = watcher()
+            if (!w) return
+
+            log.info("watcher backend", { directory: Instance.directory, platform: process.platform, backend })
+
+            const subs: ParcelWatcher.AsyncSubscription[] = []
+            yield* Effect.addFinalizer(() =>
+              Effect.promise(() => Promise.allSettled(subs.map((sub) => sub.unsubscribe()))),
+            )
+
+            const cb: ParcelWatcher.SubscribeCallback = Instance.bind((err, evts) => {
+              if (err) return
+              for (const evt of evts) {
+                if (evt.type === "create") Bus.publish(Event.Updated, { file: evt.path, event: "add" })
+                if (evt.type === "update") Bus.publish(Event.Updated, { file: evt.path, event: "change" })
+                if (evt.type === "delete") Bus.publish(Event.Updated, { file: evt.path, event: "unlink" })
+              }
+            })
+
+            const subscribe = (dir: string, ignore: string[]) => {
+              const pending = w.subscribe(dir, cb, { ignore, backend })
+              return Effect.gen(function* () {
+                const sub = yield* Effect.promise(() => pending)
+                subs.push(sub)
+              }).pipe(
+                Effect.timeout(SUBSCRIBE_TIMEOUT_MS),
+                Effect.catchCause((cause) => {
+                  log.error("failed to subscribe", { dir, cause: Cause.pretty(cause) })
+                  pending.then((s) => s.unsubscribe()).catch(() => {})
+                  return Effect.void
+                }),
+              )
+            }
+
+            const cfg = yield* config.get()
+            const cfgIgnores = cfg.watcher?.ignore ?? []
+
+            if (yield* Flag.IRODER_EXPERIMENTAL_FILEWATCHER) {
+              yield* subscribe(Instance.directory, [
+                ...FileIgnore.PATTERNS,
+                ...cfgIgnores,
+                ...protecteds(Instance.directory),
+              ])
+            }
+
+            if (Instance.project.vcs === "git") {
+              const result = yield* Effect.promise(() =>
+                Git.run(["rev-parse", "--git-dir"], {
+                  cwd: Instance.project.worktree,
+                }),
+              )
+              const vcsDir =
+                result.exitCode === 0 ? path.resolve(Instance.project.worktree, result.text().trim()) : undefined
+              if (vcsDir && !cfgIgnores.includes(".git") && !cfgIgnores.includes(vcsDir)) {
+                const ignore = (yield* Effect.promise(() => readdir(vcsDir).catch(() => []))).filter(
+                  (entry) => entry !== "HEAD",
+                )
+                yield* subscribe(vcsDir, ignore)
+              }
+            }
+          },
+          Effect.catchCause((cause) => {
+            log.error("failed to init watcher service", { cause: Cause.pretty(cause) })
+            return Effect.void
+          }),
+        ),
+      )
+
+      return Service.of({
+        init: Effect.fn("FileWatcher.init")(function* () {
+          yield* InstanceState.get(state)
+        }),
+      })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer))
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function init() {
+    return runPromise((svc) => svc.init())
+  }
+}

package/src/filesystem/index.ts

@@ -0,0 +1,236 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { dirname, join, relative, resolve as pathResolve } from "path"
+import { realpathSync } from "fs"
+import * as NFS from "fs/promises"
+import { lookup } from "mime-types"
+import { Effect, FileSystem, Layer, Schema, ServiceMap } from "effect"
+import type { PlatformError } from "effect/PlatformError"
+import { Glob } from "../util/glob"
+
+export namespace AppFileSystem {
+  export class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
+    method: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  export type Error = PlatformError | FileSystemError
+
+  export interface DirEntry {
+    readonly name: string
+    readonly type: "file" | "directory" | "symlink" | "other"
+  }
+
+  export interface Interface extends FileSystem.FileSystem {
+    readonly isDir: (path: string) => Effect.Effect<boolean>
+    readonly isFile: (path: string) => Effect.Effect<boolean>
+    readonly existsSafe: (path: string) => Effect.Effect<boolean>
+    readonly readJson: (path: string) => Effect.Effect<unknown, Error>
+    readonly writeJson: (path: string, data: unknown, mode?: number) => Effect.Effect<void, Error>
+    readonly ensureDir: (path: string) => Effect.Effect<void, Error>
+    readonly writeWithDirs: (path: string, content: string | Uint8Array, mode?: number) => Effect.Effect<void, Error>
+    readonly readDirectoryEntries: (path: string) => Effect.Effect<DirEntry[], Error>
+    readonly findUp: (target: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly up: (options: { targets: string[]; start: string; stop?: string }) => Effect.Effect<string[], Error>
+    readonly globUp: (pattern: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly glob: (pattern: string, options?: Glob.Options) => Effect.Effect<string[], Error>
+    readonly globMatch: (pattern: string, filepath: string) => boolean
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@iroder/FileSystem") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+
+      const existsSafe = Effect.fn("FileSystem.existsSafe")(function* (path: string) {
+        return yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false))
+      })
+
+      const isDir = Effect.fn("FileSystem.isDir")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "Directory"
+      })
+
+      const isFile = Effect.fn("FileSystem.isFile")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "File"
+      })
+
+      const readDirectoryEntries = Effect.fn("FileSystem.readDirectoryEntries")(function* (dirPath: string) {
+        return yield* Effect.tryPromise({
+          try: async () => {
+            const entries = await NFS.readdir(dirPath, { withFileTypes: true })
+            return entries.map(
+              (e): DirEntry => ({
+                name: e.name,
+                type: e.isDirectory() ? "directory" : e.isSymbolicLink() ? "symlink" : e.isFile() ? "file" : "other",
+              }),
+            )
+          },
+          catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause }),
+        })
+      })
+
+      const readJson = Effect.fn("FileSystem.readJson")(function* (path: string) {
+        const text = yield* fs.readFileString(path)
+        return JSON.parse(text)
+      })
+
+      const writeJson = Effect.fn("FileSystem.writeJson")(function* (path: string, data: unknown, mode?: number) {
+        const content = JSON.stringify(data, null, 2)
+        yield* fs.writeFileString(path, content)
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const ensureDir = Effect.fn("FileSystem.ensureDir")(function* (path: string) {
+        yield* fs.makeDirectory(path, { recursive: true })
+      })
+
+      const writeWithDirs = Effect.fn("FileSystem.writeWithDirs")(function* (
+        path: string,
+        content: string | Uint8Array,
+        mode?: number,
+      ) {
+        const write = typeof content === "string" ? fs.writeFileString(path, content) : fs.writeFile(path, content)
+
+        yield* write.pipe(
+          Effect.catchIf(
+            (e) => e.reason._tag === "NotFound",
+            () =>
+              Effect.gen(function* () {
+                yield* fs.makeDirectory(dirname(path), { recursive: true })
+                yield* write
+              }),
+          ),
+        )
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const glob = Effect.fn("FileSystem.glob")(function* (pattern: string, options?: Glob.Options) {
+        return yield* Effect.tryPromise({
+          try: () => Glob.scan(pattern, options),
+          catch: (cause) => new FileSystemError({ method: "glob", cause }),
+        })
+      })
+
+      const findUp = Effect.fn("FileSystem.findUp")(function* (target: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const search = join(current, target)
+          if (yield* fs.exists(search)) result.push(search)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const up = Effect.fn("FileSystem.up")(function* (options: { targets: string[]; start: string; stop?: string }) {
+        const result: string[] = []
+        let current = options.start
+        while (true) {
+          for (const target of options.targets) {
+            const search = join(current, target)
+            if (yield* fs.exists(search)) result.push(search)
+          }
+          if (options.stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const globUp = Effect.fn("FileSystem.globUp")(function* (pattern: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const matches = yield* glob(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
+            Effect.catch(() => Effect.succeed([] as string[])),
+          )
+          result.push(...matches)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      return Service.of({
+        ...fs,
+        existsSafe,
+        isDir,
+        isFile,
+        readDirectoryEntries,
+        readJson,
+        writeJson,
+        ensureDir,
+        writeWithDirs,
+        findUp,
+        up,
+        globUp,
+        glob,
+        globMatch: Glob.match,
+      })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
+
+  // Pure helpers that don't need Effect (path manipulation, sync operations)
+  export function mimeType(p: string): string {
+    return lookup(p) || "application/octet-stream"
+  }
+
+  export function normalizePath(p: string): string {
+    if (process.platform !== "win32") return p
+    const resolved = pathResolve(windowsPath(p))
+    try {
+      return realpathSync.native(resolved)
+    } catch {
+      return resolved
+    }
+  }
+
+  export function normalizePathPattern(p: string): string {
+    if (process.platform !== "win32") return p
+    if (p === "*") return p
+    const match = p.match(/^(.*)[\\/]\*$/)
+    if (!match) return normalizePath(p)
+    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1]
+    return join(normalizePath(dir), "*")
+  }
+
+  export function resolve(p: string): string {
+    const resolved = pathResolve(windowsPath(p))
+    try {
+      return normalizePath(realpathSync(resolved))
+    } catch (e: any) {
+      if (e?.code === "ENOENT") return normalizePath(resolved)
+      throw e
+    }
+  }
+
+  export function windowsPath(p: string): string {
+    if (process.platform !== "win32") return p
+    return p
+      .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+      .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
+  }
+
+  export function overlaps(a: string, b: string) {
+    const relA = relative(a, b)
+    const relB = relative(b, a)
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+  }
+
+  export function contains(parent: string, child: string) {
+    return !relative(parent, child).startsWith("..")
+  }
+}

package/src/flag/flag.ts

@@ -0,0 +1,171 @@
+import { Config } from "effect"
+
+function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+function falsy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "false" || value === "0"
+}
+
+export namespace Flag {
+  export const OTEL_EXPORTER_OTLP_ENDPOINT = process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]
+  export const OTEL_EXPORTER_OTLP_HEADERS = process.env["OTEL_EXPORTER_OTLP_HEADERS"]
+
+  export const IRODER_AUTO_SHARE = truthy("IRODER_AUTO_SHARE")
+  export const IRODER_AUTO_HEAP_SNAPSHOT = truthy("IRODER_AUTO_HEAP_SNAPSHOT")
+  export const IRODER_GIT_BASH_PATH = process.env["IRODER_GIT_BASH_PATH"]
+  export const IRODER_CONFIG = process.env["IRODER_CONFIG"]
+  export declare const IRODER_PURE: boolean
+  export declare const IRODER_TUI_CONFIG: string | undefined
+  export declare const IRODER_CONFIG_DIR: string | undefined
+  export declare const IRODER_PLUGIN_META_FILE: string | undefined
+  export const IRODER_CONFIG_CONTENT = process.env["IRODER_CONFIG_CONTENT"]
+  export const IRODER_DISABLE_AUTOUPDATE = truthy("IRODER_DISABLE_AUTOUPDATE")
+  export const IRODER_ALWAYS_NOTIFY_UPDATE = truthy("IRODER_ALWAYS_NOTIFY_UPDATE")
+  export const IRODER_DISABLE_PRUNE = truthy("IRODER_DISABLE_PRUNE")
+  export const IRODER_DISABLE_TERMINAL_TITLE = truthy("IRODER_DISABLE_TERMINAL_TITLE")
+  export const IRODER_SHOW_TTFD = truthy("IRODER_SHOW_TTFD")
+  export const IRODER_PERMISSION = process.env["IRODER_PERMISSION"]
+  export const IRODER_DISABLE_DEFAULT_PLUGINS = truthy("IRODER_DISABLE_DEFAULT_PLUGINS")
+  export const IRODER_DISABLE_LSP_DOWNLOAD = truthy("IRODER_DISABLE_LSP_DOWNLOAD")
+  export const IRODER_ENABLE_EXPERIMENTAL_MODELS = truthy("IRODER_ENABLE_EXPERIMENTAL_MODELS")
+  export const IRODER_DISABLE_AUTOCOMPACT = truthy("IRODER_DISABLE_AUTOCOMPACT")
+  export const IRODER_DISABLE_MODELS_FETCH = truthy("IRODER_DISABLE_MODELS_FETCH")
+  export const IRODER_DISABLE_MOUSE = truthy("IRODER_DISABLE_MOUSE")
+  export const IRODER_DISABLE_CLAUDE_CODE = truthy("IRODER_DISABLE_CLAUDE_CODE")
+  export const IRODER_DISABLE_CLAUDE_CODE_PROMPT =
+    IRODER_DISABLE_CLAUDE_CODE || truthy("IRODER_DISABLE_CLAUDE_CODE_PROMPT")
+  export const IRODER_DISABLE_CLAUDE_CODE_SKILLS =
+    IRODER_DISABLE_CLAUDE_CODE || truthy("IRODER_DISABLE_CLAUDE_CODE_SKILLS")
+  export const IRODER_DISABLE_EXTERNAL_SKILLS =
+    IRODER_DISABLE_CLAUDE_CODE_SKILLS || truthy("IRODER_DISABLE_EXTERNAL_SKILLS")
+  export declare const IRODER_DISABLE_PROJECT_CONFIG: boolean
+  export const IRODER_FAKE_VCS = process.env["IRODER_FAKE_VCS"]
+  export declare const IRODER_CLIENT: string
+  export const IRODER_SERVER_PASSWORD = process.env["IRODER_SERVER_PASSWORD"]
+  export const IRODER_SERVER_USERNAME = process.env["IRODER_SERVER_USERNAME"]
+  export const IRODER_ENABLE_QUESTION_TOOL = truthy("IRODER_ENABLE_QUESTION_TOOL")
+  export declare const IRODER_ENABLE_EXT_CMDS: boolean
+
+  // Experimental
+  export const IRODER_EXPERIMENTAL = truthy("IRODER_EXPERIMENTAL")
+  export const IRODER_EXPERIMENTAL_FILEWATCHER = Config.boolean("IRODER_EXPERIMENTAL_FILEWATCHER").pipe(
+    Config.withDefault(false),
+  )
+  export const IRODER_EXPERIMENTAL_DISABLE_FILEWATCHER = Config.boolean(
+    "IRODER_EXPERIMENTAL_DISABLE_FILEWATCHER",
+  ).pipe(Config.withDefault(false))
+  export const IRODER_EXPERIMENTAL_ICON_DISCOVERY =
+    IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_ICON_DISCOVERY")
+
+  const copy = process.env["IRODER_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"]
+  export const IRODER_EXPERIMENTAL_DISABLE_COPY_ON_SELECT =
+    copy === undefined ? process.platform === "win32" : truthy("IRODER_EXPERIMENTAL_DISABLE_COPY_ON_SELECT")
+  export const IRODER_ENABLE_EXA =
+    truthy("IRODER_ENABLE_EXA") || IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_EXA")
+  export const IRODER_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("IRODER_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS")
+  export const IRODER_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("IRODER_EXPERIMENTAL_OUTPUT_TOKEN_MAX")
+  export const IRODER_EXPERIMENTAL_OXFMT = IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_OXFMT")
+  export const IRODER_EXPERIMENTAL_LSP_TY = truthy("IRODER_EXPERIMENTAL_LSP_TY")
+  export const IRODER_EXPERIMENTAL_LSP_TOOL = IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_LSP_TOOL")
+  export const IRODER_DISABLE_FILETIME_CHECK = Config.boolean("IRODER_DISABLE_FILETIME_CHECK").pipe(
+    Config.withDefault(false),
+  )
+  export const IRODER_EXPERIMENTAL_PLAN_MODE = IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_PLAN_MODE")
+  export const IRODER_EXPERIMENTAL_WORKSPACES = IRODER_EXPERIMENTAL || truthy("IRODER_EXPERIMENTAL_WORKSPACES")
+  export const IRODER_EXPERIMENTAL_MARKDOWN = !falsy("IRODER_EXPERIMENTAL_MARKDOWN")
+  export const IRODER_MODELS_URL = process.env["IRODER_MODELS_URL"]
+  export const IRODER_MODELS_PATH = process.env["IRODER_MODELS_PATH"]
+  export const IRODER_DISABLE_EMBEDDED_WEB_UI = truthy("IRODER_DISABLE_EMBEDDED_WEB_UI")
+  export const IRODER_DB = process.env["IRODER_DB"]
+  export const IRODER_DISABLE_CHANNEL_DB = truthy("IRODER_DISABLE_CHANNEL_DB")
+  export const IRODER_SKIP_MIGRATIONS = truthy("IRODER_SKIP_MIGRATIONS")
+  export const IRODER_STRICT_CONFIG_DEPS = truthy("IRODER_STRICT_CONFIG_DEPS")
+
+  function number(key: string) {
+    const value = process.env[key]
+    if (!value) return undefined
+    const parsed = Number(value)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+  }
+}
+
+// Dynamic getter for IRODER_DISABLE_PROJECT_CONFIG
+// This must be evaluated at access time, not module load time,
+// because external tooling may set this env var at runtime
+Object.defineProperty(Flag, "IRODER_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("IRODER_DISABLE_PROJECT_CONFIG")
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_TUI_CONFIG
+// This must be evaluated at access time, not module load time,
+// because tests and external tooling may set this env var at runtime
+Object.defineProperty(Flag, "IRODER_TUI_CONFIG", {
+  get() {
+    return process.env["IRODER_TUI_CONFIG"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_CONFIG_DIR
+// This must be evaluated at access time, not module load time,
+// because external tooling may set this env var at runtime
+Object.defineProperty(Flag, "IRODER_CONFIG_DIR", {
+  get() {
+    return process.env["IRODER_CONFIG_DIR"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_PURE
+// This must be evaluated at access time, not module load time,
+// because the CLI can set this flag at runtime
+Object.defineProperty(Flag, "IRODER_PURE", {
+  get() {
+    return truthy("IRODER_PURE")
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_PLUGIN_META_FILE
+// This must be evaluated at access time, not module load time,
+// because tests and external tooling may set this env var at runtime
+Object.defineProperty(Flag, "IRODER_PLUGIN_META_FILE", {
+  get() {
+    return process.env["IRODER_PLUGIN_META_FILE"]
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_CLIENT
+// This must be evaluated at access time, not module load time,
+// because some commands override the client at runtime
+Object.defineProperty(Flag, "IRODER_CLIENT", {
+  get() {
+    return process.env["IRODER_CLIENT"] ?? "cli"
+  },
+  enumerable: true,
+  configurable: false,
+})
+
+// Dynamic getter for IRODER_ENABLE_EXT_CMDS
+// This must be evaluated at access time, not module load time,
+// because tests may toggle this env var at runtime
+Object.defineProperty(Flag, "IRODER_ENABLE_EXT_CMDS", {
+  get() {
+    return truthy("IRODER_ENABLE_EXT_CMDS")
+  },
+  enumerable: true,
+  configurable: false,
+})