opencode-drive 0.1.1 → 0.1.3

package/src/cli/index.ts

@@ -2,71 +2,87 @@
 import { NodeRuntime, NodeServices } from "@effect/platform-node"
 import { Effect, Option } from "effect"
 import { Command, Flag } from "effect/unstable/cli"
-import { send } from "./send.js"
-import { describe } from "./describe.js"
+import { api } from "./api.js"
 import { extractCommands } from "./parse.js"
+import { send } from "./send.js"
 import { start } from "./start.js"
-import { stop } from "./stop.js"
+import { restart } from "./restart.js"
 import type { DriveCommand, SendOptions, StartOptions } from "./types.js"
 
 const extracted = extract()
-const name = Flag.string("name").pipe(Flag.optional, Flag.withDescription("Instance name"))
-const driver = Flag.string("driver").pipe(Flag.optional, Flag.withDescription("TypeScript driver module"))
 
-const startCommand = Command.make("start", {
-  name,
-  driver,
-  campaign: Flag.string("campaign").pipe(Flag.optional, Flag.withDescription("Campaign module")),
-  seed: Flag.integer("seed").pipe(Flag.withDefault(Date.now() % 1_000_000)),
-  caseIndex: Flag.integer("case").pipe(
-    Flag.filter((value) => value >= 0, () => "Case must be non-negative"),
-    Flag.optional,
-  ),
-  count: Flag.integer("count").pipe(
-    Flag.filter((value) => value > 0, () => "Count must be greater than zero"),
-    Flag.optional,
-  ),
-  concurrency: Flag.integer("concurrency").pipe(
-    Flag.filter((value) => value > 0, () => "Concurrency must be greater than zero"),
-    Flag.withDefault(1),
-  ),
-  visible: Flag.boolean("visible").pipe(Flag.withDescription("Show OpenCode in the terminal")),
-  detach: Flag.boolean("detach").pipe(Flag.withDescription("Keep OpenCode running in the background (default)")),
-  dev: Flag.string("dev").pipe(Flag.optional, Flag.withDescription("Path to an OpenCode development checkout")),
-  state: Flag.string("state").pipe(Flag.optional, Flag.withDescription("Simulation snapshot containing files/")),
-  anchor: Flag.string("anchor").pipe(Flag.optional),
-}, (config) => execute(() => start(toStartOptions(config, extracted.commands, extracted.app)))).pipe(
-  Command.withDescription("Launch and own a local simulated OpenCode instance"),
+const startCommand = Command.make(
+  "start",
+  {
+    script: Flag.string("script").pipe(
+      Flag.optional,
+      Flag.withDescription("JavaScript or TypeScript automation module"),
+    ),
+    visible: Flag.boolean("visible").pipe(
+      Flag.withDescription("Show OpenCode in the terminal"),
+    ),
+    dev: Flag.string("dev").pipe(
+      Flag.optional,
+      Flag.withDescription("Path to an OpenCode development checkout"),
+    ),
+    state: Flag.string("state").pipe(
+      Flag.optional,
+      Flag.withDescription("Simulation snapshot containing files/"),
+    ),
+  },
+  (config) =>
+    execute(() =>
+      start(toStartOptions(config, extracted.commands, extracted.app)),
+    ),
+).pipe(
+  Command.withDescription("Launch a local simulated OpenCode instance"),
   Command.withExamples([
-    { command: "opencode-drive start --name demo --visible", description: "Launch a visible simulated instance" },
-    { command: "opencode-drive start --name demo --detach", description: "Launch a background simulated instance" },
+    {
+      command: "opencode-drive start",
+      description: "Launch headless OpenCode on the default ports",
+    },
+    {
+      command: "opencode-drive start --visible",
+      description: "Launch visible OpenCode on the default ports",
+    },
+    {
+      command: "opencode-drive start --script ./drive.ts",
+      description: "Launch headless OpenCode and run a script",
+    },
   ]),
 )
 
-const sendCommand = Command.make("send", { name, driver }, (config) =>
-  execute(() => send(toSendOptions(config, extracted.commands, extracted.app)))).pipe(
-    Command.withDescription("Connect to an existing drive-enabled OpenCode instance"),
-    Command.withExamples([
-      {
-        command: "opencode-drive send --name demo --command.type hello --command.press enter --command.render --command.state",
-        description: "Execute an ordered command batch",
-      },
-    ]),
-  )
+const sendCommand = Command.make("send", {}, () =>
+  execute(() => send(toSendOptions(extracted.commands, extracted.app))),
+).pipe(
+  Command.withDescription("Send UI commands to OpenCode on the default port"),
+  Command.withExamples([
+    {
+      command:
+        'opencode-drive send --command.ui.type \'{"text":"hello"}\' --command.ui.state',
+      description: "Execute an ordered UI command batch",
+    },
+  ]),
+)
 
-const describeCommand = Command.make("describe", { name }, (config) =>
-  execute(() => describe(Option.getOrUndefined(config.name)))).pipe(
-    Command.withDescription("Describe a registered OpenCode instance"),
-  )
+const apiCommand = Command.make("api", {}, () => execute(api)).pipe(
+  Command.withDescription("Print the OpenCode drive UI protocol"),
+)
 
-const stopCommand = Command.make("stop", { name }, (config) =>
-  execute(() => stop(Option.getOrUndefined(config.name)))).pipe(
-    Command.withDescription("Stop a registered headless OpenCode instance"),
-  )
+const restartCommand = Command.make("restart", {}, () => execute(restart)).pipe(
+  Command.withDescription(
+    "Restart the active visible OpenCode instance and rerun its script",
+  ),
+)
 
 const root = Command.make("opencode-drive").pipe(
   Command.withDescription("Drive real and simulated OpenCode instances"),
-  Command.withSubcommands([startCommand, sendCommand, describeCommand, stopCommand]),
+  Command.withSubcommands([
+    startCommand,
+    sendCommand,
+    restartCommand,
+    apiCommand,
+  ]),
 )
 
 Command.runWith(root, { version: "0.1.0" })(extracted.args).pipe(
@@ -76,81 +92,47 @@ Command.runWith(root, { version: "0.1.0" })(extracted.args).pipe(
 
 function toStartOptions(
   config: {
-    readonly name: Option.Option<string>
-    readonly driver: Option.Option<string>
-    readonly campaign: Option.Option<string>
-    readonly seed: number
-    readonly caseIndex: Option.Option<number>
-    readonly count: Option.Option<number>
-    readonly concurrency: number
+    readonly script: Option.Option<string>
     readonly visible: boolean
-    readonly detach: boolean
     readonly dev: Option.Option<string>
     readonly state: Option.Option<string>
-    readonly anchor: Option.Option<string>
   },
   commands: ReadonlyArray<DriveCommand>,
   app: ReadonlyArray<string>,
 ): StartOptions {
-  const driver = Option.getOrUndefined(config.driver)
-  const campaign = Option.getOrUndefined(config.campaign)
-  const visible = config.visible
+  if (commands.length > 0)
+    throw new Error("start does not accept command flags; use send or --script")
   const options = {
     kind: "start" as const,
-    name: Option.getOrUndefined(config.name),
-    driver,
-    campaign,
-    seed: config.seed,
-    caseIndex: Option.getOrUndefined(config.caseIndex),
-    count: Option.getOrUndefined(config.count),
-    concurrency: config.concurrency,
-    visible,
-    detach: !visible && (config.detach || (driver === undefined && campaign === undefined && commands.length === 0)),
+    script: Option.getOrUndefined(config.script),
+    visible: config.visible,
     dev: Option.getOrUndefined(config.dev),
     state: Option.getOrUndefined(config.state),
-    anchor: Option.getOrUndefined(config.anchor),
     command: app,
-    commands,
-  }
-  assertExecutionMode(options.driver, options.campaign, commands)
-  if (options.dev !== undefined && app.length > 0) throw new Error("--dev cannot be combined with a command after --")
-  if (options.caseIndex !== undefined && options.campaign === undefined) throw new Error("--case requires --campaign")
-  if (options.visible && options.campaign !== undefined && options.caseIndex === undefined) {
-    throw new Error("visible campaign runs require --case")
-  }
-  if (config.detach && (options.driver !== undefined || options.campaign !== undefined || commands.length > 0)) {
-    throw new Error("--detach cannot be combined with --driver, --campaign, or command flags")
   }
+  if (options.dev !== undefined && app.length > 0)
+    throw new Error("--dev cannot be combined with a command after --")
   return options
 }
 
 function toSendOptions(
-  config: { readonly name: Option.Option<string>; readonly driver: Option.Option<string> },
   commands: ReadonlyArray<DriveCommand>,
   app: ReadonlyArray<string>,
 ): SendOptions {
   if (app.length > 0) throw new Error("send does not accept a command after --")
-  const options = {
-    kind: "send" as const,
-    name: Option.getOrUndefined(config.name),
-    driver: Option.getOrUndefined(config.driver),
-    commands,
-  }
-  assertExecutionMode(options.driver, undefined, commands)
-  return options
-}
-
-function assertExecutionMode(driver: string | undefined, campaign: string | undefined, commands: ReadonlyArray<DriveCommand>) {
-  const count = Number(driver !== undefined) + Number(campaign !== undefined) + Number(commands.length > 0)
-  if (count > 1) throw new Error("command flags, --driver, and --campaign are mutually exclusive")
+  return { kind: "send", commands }
 }
 
 function execute(task: () => Promise<void>) {
   return Effect.tryPromise({ try: task, catch: (error) => error }).pipe(
-    Effect.catch((error) => Effect.sync(() => {
-      console.error(`error: ${error instanceof Error ? error.message : String(error)}`)
-      process.exitCode = 1
-    })),
+    Effect.catch((error) =>
+      Effect.sync(() => {
+        console.error(
+          `error: ${error instanceof Error ? error.message : String(error)}`,
+        )
+        process.exitCode = 1
+      }),
+    ),
   )
 }
 
@@ -158,7 +140,9 @@ function extract() {
   try {
     return extractCommands(process.argv.slice(2))
   } catch (error) {
-    console.error(`opencode-drive: ${error instanceof Error ? error.message : String(error)}`)
+    console.error(
+      `opencode-drive: ${error instanceof Error ? error.message : String(error)}`,
+    )
     return process.exit(1)
   }
 }

package/src/cli/instance.ts

@@ -1,47 +1,40 @@
 import { mkdir, rm } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join, resolve } from "node:path"
-import { registerInstance, registryDirectory, transferInstance, unregisterInstance } from "./registry.js"
-import type { InstanceManifest } from "./types.js"
+import { defaultBackendPort, defaultPort } from "../client/index.js"
 
 export interface LaunchOptions {
-  readonly name?: string
+  readonly name: string
   readonly command?: ReadonlyArray<string>
   readonly dev?: string
   readonly state?: string
+  readonly scripted?: boolean
   readonly visible?: boolean
   readonly env?: Readonly<Record<string, string>>
 }
 
 export async function launchInstance(options: LaunchOptions = {}) {
-  const name = options.name ?? "default"
-  const artifacts = resolve(join(tmpdir(), "opencode-drive", `${name}-${randomSuffix()}`))
-  const cwd = artifacts
-  const [uiPort, backendPort] = await Promise.all([freePort(), freePort()])
+  const artifacts = resolve(
+    join(tmpdir(), "opencode-drive", `run-${crypto.randomUUID().slice(0, 6)}`),
+  )
+  const logs = join(artifacts, "logs")
   const endpoints = {
-    ui: `ws://127.0.0.1:${uiPort}`,
-    backend: `ws://127.0.0.1:${backendPort}`,
-  }
-  const manifest: InstanceManifest = {
-    version: 1,
-    name,
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    mode: "simulated",
-    headless: options.visible !== true,
-    cwd,
-    artifacts,
-    endpoints,
+    ui: `ws://127.0.0.1:${await freePort()}`,
+    backend: `ws://127.0.0.1:${await freePort()}`,
   }
+  const drive = join(artifacts, "drive")
   await Promise.all([
-    mkdir(artifacts, { recursive: true }),
-    mkdir(cwd, { recursive: true }),
+    mkdir(logs, { recursive: true }),
+    mkdir(drive, { recursive: true }),
     mkdir(join(artifacts, "home", ".cache"), { recursive: true }),
     mkdir(join(artifacts, "home", ".config"), { recursive: true }),
     mkdir(join(artifacts, "home", ".local", "share"), { recursive: true }),
     mkdir(join(artifacts, "home", ".local", "state"), { recursive: true }),
   ])
-  const state = options.state ? resolve(options.state) : join(artifacts, "state")
+  await Bun.write(join(drive, `${options.name}.json`), `${JSON.stringify({ endpoints }, undefined, 2)}\n`)
+  const state = options.state
+    ? resolve(options.state)
+    : join(artifacts, "state")
   if (!options.state) {
     await rm(state, { recursive: true, force: true })
     await Promise.all([
@@ -57,16 +50,17 @@ export async function launchInstance(options: LaunchOptions = {}) {
           providers: {
             simulation: {
               name: "Simulation",
+              package: "aisdk:@ai-sdk/openai-compatible",
+              settings: { baseURL: "https://api.openai.com/v1" },
               request: { body: { apiKey: "sim-key" } },
               models: {
                 "sim-model": {
                   name: "Simulated Model",
-                  api: {
-                    type: "aisdk",
-                    package: "@ai-sdk/openai-compatible",
-                    url: "https://api.openai.com/v1",
+                  capabilities: {
+                    tools: true,
+                    input: ["text"],
+                    output: ["text"],
                   },
-                  capabilities: { tools: true, input: ["text"], output: ["text"] },
                   limit: { context: 128000, output: 16000 },
                 },
               },
@@ -78,121 +72,243 @@ export async function launchInstance(options: LaunchOptions = {}) {
       )}\n`,
     )
   }
-  await registerInstance(manifest)
   const environment = cleanEnv({
     ...process.env,
     ...options.env,
-    DRIVE_REGISTRY_DIR: registryDirectory(),
     OPENCODE_SIMULATE: "1",
     OPENCODE_SIMULATE_STATE: state,
-    OPENCODE_DRIVE: name,
+    DRIVE_REGISTRY_DIR: drive,
+    OPENCODE_DRIVE: options.name,
     OPENCODE_DRIVE_RENDERER: options.visible ? "visible" : "headless",
-    OPENCODE_CONFIG_DIR: join(cwd, ".opencode"),
+    OPENCODE_CONFIG_DIR: join(artifacts, ".opencode"),
     OPENCODE_DB: ":memory:",
+    OPENCODE_LOG_LEVEL: !options.visible
+      ? "INFO"
+      : process.env.OPENCODE_LOG_LEVEL,
+    OPENCODE_TEST_HOME: artifacts,
     XDG_CACHE_HOME: join(artifacts, "home", ".cache"),
     XDG_CONFIG_HOME: join(artifacts, "home", ".config"),
-    XDG_DATA_HOME: join(artifacts, "home", ".local", "share"),
+    XDG_DATA_HOME: logs,
     XDG_STATE_HOME: join(artifacts, "home", ".local", "state"),
   })
   const command = options.dev
-    ? await prepareDev(cwd, options.dev)
+    ? await prepareDev(artifacts, options.dev)
     : options.command?.length
       ? [...options.command]
-      : ["opencode2", "--standalone"]
-  const visible = options.visible === true
-  const child = Bun.spawn(command, {
-    cwd,
-    env: environment,
-    stdin: visible ? "inherit" : "ignore",
-    stdout: visible ? "inherit" : Bun.file(join(artifacts, "opencode.stdout.log")),
-    stderr: visible ? "inherit" : Bun.file(join(artifacts, "opencode.stderr.log")),
-  })
-  const lifecycle = { detached: false, stopping: undefined as Promise<void> | undefined }
+      : ["opencode2"]
+  const spawn = () =>
+    Bun.spawn(command, {
+      cwd: artifacts,
+      env: environment,
+      stdin: options.visible ? "inherit" : "ignore",
+      stdout: !options.visible
+        ? Bun.file(join(logs, "opencode.stdout.log"))
+        : "inherit",
+      stderr: !options.visible
+        ? Bun.file(join(logs, "opencode.stderr.log"))
+        : "inherit",
+    })
+  let child = spawn()
+  let stopping: Promise<void> | undefined
+  let restarting: Promise<void> | undefined
   return {
-    manifest,
-    child,
-    async waitForDrive(requirement: "ui" | "backend" | "both" = "both", timeout = 60_000) {
-      const urls = requirement === "both"
-        ? [endpoints.ui, endpoints.backend]
-        : [requirement === "ui" ? endpoints.ui : endpoints.backend]
-      await Promise.all(urls.map((url) => waitForWebSocket(url, child.exited, timeout)))
+    artifacts,
+    logs,
+    endpoints,
+    get child() {
+      return child
     },
-    async detach() {
-      await transferInstance(manifest, child.pid)
-      child.unref()
-      lifecycle.detached = true
+    async waitForDrive(
+      requirement: "ui" | "backend" | "both" = "both",
+      timeout = 60_000,
+    ) {
+      const urls =
+        requirement === "both"
+          ? [endpoints.ui, endpoints.backend]
+          : [endpoints[requirement]]
+      await Promise.all(
+        urls.map((url) => waitForWebSocket(url, child.exited, timeout)),
+      )
     },
-    stop(force = false) {
-      if (lifecycle.detached) return Promise.resolve()
-      if (lifecycle.stopping) return lifecycle.stopping
-      lifecycle.stopping = (async () => {
-        if (force) {
-          if (child.exitCode === null) child.kill("SIGKILL")
-        } else if (child.exitCode === null) {
-          child.kill("SIGTERM")
-          await Promise.race([child.exited, Bun.sleep(1_000)])
+    async restart() {
+      if (restarting) return restarting
+      restarting = (async () => {
+        await terminate(child)
+        child = spawn()
+        await Promise.all([
+          waitForWebSocket(endpoints.ui, child.exited, 60_000),
+          waitForWebSocket(endpoints.backend, child.exited, 60_000),
+        ])
+      })().finally(() => {
+        restarting = undefined
+      })
+      return restarting
+    },
+    async wait() {
+      while (true) {
+        const current = child
+        const status = await current.exited
+        if (restarting) {
+          await restarting
+          continue
         }
-        if (child.exitCode === null) child.kill("SIGKILL")
-        await child.exited
-        await unregisterInstance(name, process.pid)
+        if (current !== child) continue
+        return status
+      }
+    },
+    stop() {
+      if (stopping) return stopping
+      stopping = (async () => {
+        if (restarting) await restarting.catch(() => undefined)
+        await terminate(child)
+        await stopService(join(artifacts, "home", ".local", "state"))
       })()
-      return lifecycle.stopping
+      return stopping
     },
   }
 }
 
+async function terminate(child: Bun.Subprocess) {
+  if (child.exitCode !== null) return
+  child.kill("SIGTERM")
+  await Promise.race([child.exited, Bun.sleep(1_000)])
+  if (child.exitCode === null) child.kill("SIGKILL")
+  await child.exited
+}
+
 async function prepareDev(cwd: string, directory: string) {
   const root = resolve(directory)
   const entrypoint = join(root, "packages", "cli", "src", "index.ts")
-  if (!(await Bun.file(entrypoint).exists())) throw new Error(`OpenCode development entrypoint not found: ${entrypoint}`)
-  const solidPackage = join(root, "packages", "tui", "node_modules", "@opentui", "solid", "package.json")
+  if (!(await Bun.file(entrypoint).exists()))
+    throw new Error(`OpenCode development entrypoint not found: ${entrypoint}`)
+  const solidPackage = join(
+    root,
+    "packages",
+    "tui",
+    "node_modules",
+    "@opentui",
+    "solid",
+    "package.json",
+  )
   if (!(await Bun.file(solidPackage).exists())) {
-    throw new Error(`OpenCode development dependency not found: ${solidPackage}; run bun install in ${root}`)
+    throw new Error(
+      `OpenCode development dependency not found: ${solidPackage}; run bun install in ${root}`,
+    )
   }
   const info: unknown = await Bun.file(solidPackage).json()
-  if (!isPackageInfo(info)) throw new Error(`Invalid @opentui/solid package metadata: ${solidPackage}`)
-  await Bun.write(join(cwd, "package.json"), `${JSON.stringify({
-    private: true,
-    dependencies: { "@opentui/solid": info.version },
-  }, undefined, 2)}\n`)
+  if (!isPackageInfo(info))
+    throw new Error(`Invalid @opentui/solid package metadata: ${solidPackage}`)
+  await Bun.write(
+    join(cwd, "package.json"),
+    `${JSON.stringify(
+      {
+        private: true,
+        dependencies: { "@opentui/solid": info.version },
+      },
+      undefined,
+      2,
+    )}\n`,
+  )
   const install = Bun.spawn([process.execPath, "install"], {
     cwd,
     stdin: "ignore",
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: "ignore",
+    stderr: "ignore",
   })
   const status = await install.exited
-  if (status !== 0) throw new Error(`bun install failed in ${cwd} with status ${status}`)
+  if (status !== 0)
+    throw new Error(`bun install failed in ${cwd} with status ${status}`)
   return [
     process.execPath,
     "--conditions=browser",
     "--preload=@opentui/solid/preload",
     entrypoint,
-    "--standalone",
   ]
 }
 
-function isPackageInfo(value: unknown): value is { readonly version: string } {
-  return typeof value === "object" && value !== null && "version" in value && typeof value.version === "string"
-}
-
 async function freePort() {
-  const server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response() })
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch: () => new Response(),
+  })
   const port = server.port
   await server.stop(true)
   return port
 }
 
-async function waitForWebSocket(url: string, exited: Promise<number>, timeout: number) {
+async function stopService(state: string) {
+  const files = [
+    join(state, "opencode", "service-local.json"),
+    join(state, "opencode", "service.json"),
+  ]
+  const info = await Promise.all(
+    files.map((file) =>
+      Bun.file(file)
+        .json()
+        .catch(() => undefined),
+    ),
+  )
+  await Promise.all(
+    info.map(async (value) => {
+      if (!isServiceInfo(value)) return
+      try {
+        process.kill(value.pid, "SIGTERM")
+      } catch {
+        return
+      }
+      const deadline = Date.now() + 1_000
+      while (Date.now() < deadline && alive(value.pid)) await Bun.sleep(25)
+      if (alive(value.pid)) process.kill(value.pid, "SIGKILL")
+    }),
+  )
+}
+
+function isServiceInfo(value: unknown): value is { readonly pid: number } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "pid" in value &&
+    typeof value.pid === "number"
+  )
+}
+
+function alive(pid: number) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isPackageInfo(value: unknown): value is { readonly version: string } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "version" in value &&
+    typeof value.version === "string"
+  )
+}
+
+async function waitForWebSocket(
+  url: string,
+  exited: Promise<number>,
+  timeout: number,
+) {
   const deadline = Date.now() + timeout
   while (Date.now() < deadline) {
     const connected = await Promise.race([
-      open(url).then((socket) => {
-        socket.close()
-        return true
-      }).catch(() => false),
+      open(url)
+        .then((socket) => {
+          socket.close()
+          return true
+        })
+        .catch(() => false),
       exited.then((code) => {
-        throw new Error(`OpenCode exited with status ${code} before ${url} became ready`)
+        throw new Error(
+          `OpenCode exited with status ${code} before ${url} became ready`,
+        )
       }),
     ])
     if (connected) return
@@ -204,15 +320,21 @@ async function waitForWebSocket(url: string, exited: Promise<number>, timeout: n
 function open(url: string) {
   return new Promise<WebSocket>((resolveSocket, reject) => {
     const socket = new WebSocket(url)
-    socket.addEventListener("open", () => resolveSocket(socket), { once: true })
-    socket.addEventListener("error", () => reject(new Error(`cannot connect to ${url}`)), { once: true })
+    socket.addEventListener("open", () => resolveSocket(socket), {
+      once: true,
+    })
+    socket.addEventListener(
+      "error",
+      () => reject(new Error(`cannot connect to ${url}`)),
+      { once: true },
+    )
   })
 }
 
-function randomSuffix() {
-  return crypto.randomUUID().slice(0, 6)
-}
-
 function cleanEnv(env: Readonly<Record<string, string | undefined>>) {
-  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined))
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      (entry): entry is [string, string] => entry[1] !== undefined,
+    ),
+  )
 }