@miaws/miaw 1.18.3 → 1.18.5

package/src/config/tui.ts

@@ -0,0 +1,274 @@
+export * as TuiConfig from "./tui"
+
+import path from "path"
+import { mergeDeep, unique } from "remeda"
+import { Cause, Context, Effect, Fiber, Layer } from "effect"
+import { ConfigParse } from "@/config/parse"
+import * as ConfigPaths from "@/config/paths"
+import { migrateTuiConfig } from "./tui-migrate"
+import { resolveHostAttentionSoundPaths } from "./tui-host-attention"
+import { Flag } from "@miaw/core/flag/flag"
+import { isRecord } from "@miaw/tui/util/record"
+import { Global } from "@miaw/core/global"
+import { FSUtil } from "@miaw/core/fs-util"
+import { CurrentWorkingDirectory } from "./tui-cwd"
+import { ConfigPlugin } from "@/config/plugin"
+import { TuiKeybind } from "@miaw/tui/config/keybind"
+import { InstallationLocal, InstallationVersion } from "@miaw/core/installation/version"
+import { makeRuntime } from "@miaw/core/effect/runtime"
+import { Filesystem } from "@/util/filesystem"
+import { ConfigVariable } from "@/config/variable"
+import { Npm } from "@miaw/core/npm"
+import { FormatError, FormatUnknownError } from "@/cli/error"
+import { TuiConfig } from "@miaw/tui/config"
+
+export const Info = TuiConfig.Info
+export type Info = TuiConfig.Info
+
+type Acc = {
+  result: Info
+  plugin_origins: ConfigPlugin.Origin[]
+}
+
+export type Resolved = TuiConfig.Resolved
+
+export type HostMetadata = {
+  plugin_origins?: ConfigPlugin.Origin[]
+}
+
+export interface Interface {
+  readonly get: () => Effect.Effect<Resolved>
+  readonly pluginOrigins: () => Effect.Effect<ConfigPlugin.Origin[]>
+  readonly waitForDependencies: () => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@miaw/TuiConfig") {}
+
+function pluginScope(file: string, ctx: { directory: string }): ConfigPlugin.Scope {
+  if (Filesystem.contains(ctx.directory, file)) return "local"
+  // if (ctx.worktree !== "/" && Filesystem.contains(ctx.worktree, file)) return "local"
+  return "global"
+}
+
+function normalize(raw: Record<string, unknown>) {
+  const data = { ...raw }
+  if (!("tui" in data)) return data
+  if (!isRecord(data.tui)) {
+    delete data.tui
+    return data
+  }
+
+  const tui = data.tui
+  delete data.tui
+  return {
+    ...tui,
+    ...data,
+  }
+}
+
+function dropUnknownKeybinds(input: Record<string, unknown>) {
+  if (!isRecord(input.keybinds)) return input
+
+  const invalid = TuiKeybind.unknownKeys(input.keybinds)
+  if (!invalid.length) return input
+
+  return {
+    ...input,
+    keybinds: Object.fromEntries(Object.entries(input.keybinds).filter(([key]) => !invalid.includes(key))),
+  }
+}
+
+const loadState = Effect.fn("TuiConfig.loadState")(function* (ctx: { directory: string }) {
+  const afs = yield* FSUtil.Service
+  let appliedOrder = 0
+
+  const resolvePlugins = (config: Info, configFilepath: string): Effect.Effect<Info> =>
+    Effect.gen(function* () {
+      const plugins = config.plugin
+      if (!plugins) return config
+      return {
+        ...config,
+        plugin: yield* Effect.forEach(plugins, (plugin) =>
+          Effect.promise(() => ConfigPlugin.resolvePluginSpec(plugin as ConfigPlugin.Origin["spec"], configFilepath)),
+        ),
+      }
+    })
+
+  const load = (text: string, configFilepath: string): Effect.Effect<Info> =>
+    Effect.gen(function* () {
+      const expanded = yield* Effect.promise(() =>
+        ConfigVariable.substitute({ text, type: "path", path: configFilepath, missing: "empty" }),
+      )
+      const data = ConfigParse.jsonc(expanded, configFilepath)
+      if (!isRecord(data)) return {} as Info
+      // Flatten a nested "tui" key so users who wrote `{ "tui": { ... } }` inside tui.json
+      // (mirroring the old miaw.json shape) still get their settings applied.
+      const normalized = dropUnknownKeybinds(normalize(data))
+      const parsed = ConfigParse.schema(Info, normalized, configFilepath)
+      const validated = parsed.attention?.sounds
+        ? {
+            ...parsed,
+            attention: {
+              ...parsed.attention,
+              sounds: resolveHostAttentionSoundPaths(path.dirname(configFilepath), parsed.attention.sounds),
+            },
+          }
+        : parsed
+      return yield* resolvePlugins(validated, configFilepath)
+    }).pipe(
+      // catchCause (not tapErrorCause + orElseSucceed) because JSONC parsing and validation
+      // can sync-throw — those become defects, which orElseSucceed wouldn't catch.
+      Effect.catchCause((cause) =>
+        Effect.logWarning("skipping invalid tui config", {
+          path: configFilepath,
+          reason: FormatError(Cause.squash(cause)) ?? FormatUnknownError(Cause.squash(cause)),
+        }).pipe(Effect.as({} as Info)),
+      ),
+    )
+
+  const loadFile = (filepath: string): Effect.Effect<Info> =>
+    Effect.gen(function* () {
+      // Silent-swallow non-NotFound read errors (perms, EISDIR, IO) → log + skip.
+      // Matches how parse/schema/plugin failures in load() are handled — every
+      // broken-config path degrades gracefully rather than crashing TUI startup.
+      const text = yield* afs.readFileStringSafe(filepath).pipe(
+        Effect.catchCause((cause) =>
+          Effect.logWarning("failed to read tui config", {
+            path: filepath,
+            reason: FormatError(Cause.squash(cause)) ?? FormatUnknownError(Cause.squash(cause)),
+          }).pipe(Effect.as(undefined)),
+        ),
+      )
+      if (!text) return {} as Info
+      yield* Effect.logInfo("loading tui config", { path: filepath })
+      return yield* load(text, filepath)
+    })
+
+  const mergeFile = (acc: Acc, file: string) =>
+    Effect.gen(function* () {
+      const data = yield* loadFile(file)
+      if (Object.keys(data).length) {
+        appliedOrder += 1
+        yield* Effect.logInfo("applying tui config", { path: file, order: appliedOrder })
+      }
+      acc.result = mergeDeep(acc.result, data)
+      if (!data.plugin?.length) return
+
+      const scope = pluginScope(file, ctx)
+      const plugins = ConfigPlugin.deduplicatePluginOrigins([
+        ...acc.plugin_origins,
+        ...data.plugin.map((spec) => ({ spec: spec as ConfigPlugin.Origin["spec"], scope, source: file })),
+      ])
+      acc.result = {
+        ...acc.result,
+        plugin: plugins.map((item) => item.spec),
+      }
+      acc.plugin_origins = plugins
+    })
+
+  // Every config dir we may read from: global config dir, any `.miaw`
+  // folders between cwd and home, and MIAW_CONFIG_DIR.
+  const directories = yield* ConfigPaths.directories(ctx.directory)
+  yield* Effect.promise(() => migrateTuiConfig({ directories, cwd: ctx.directory }))
+
+  const projectFiles = Flag.MIAW_DISABLE_PROJECT_CONFIG ? [] : yield* ConfigPaths.files("tui", ctx.directory)
+
+  const acc: Acc = {
+    result: {},
+    plugin_origins: [],
+  }
+
+  // 1. Global tui config (lowest precedence).
+  for (const file of ConfigPaths.fileInDirectory(Global.Path.config, "tui")) {
+    yield* mergeFile(acc, file)
+  }
+
+  // 2. Explicit MIAW_TUI_CONFIG override, if set.
+  if (Flag.MIAW_TUI_CONFIG) {
+    const configFile = Flag.MIAW_TUI_CONFIG
+    yield* mergeFile(acc, configFile)
+    yield* Effect.logDebug("loaded custom tui config", { path: configFile })
+  }
+
+  // 3. Project tui files, applied root-first so the closest file wins.
+  for (const file of projectFiles) {
+    yield* mergeFile(acc, file)
+  }
+
+  // 4. `.miaw` directories (and MIAW_CONFIG_DIR) discovered while
+  // walking up the tree. Also returned below so callers can install plugin
+  // dependencies from each location.
+  const dirs = unique(directories).filter((dir) => dir.endsWith(".miaw") || dir === Flag.MIAW_CONFIG_DIR)
+
+  for (const dir of dirs) {
+    if (!dir.endsWith(".miaw") && dir !== Flag.MIAW_CONFIG_DIR) continue
+    for (const file of ConfigPaths.fileInDirectory(dir, "tui")) {
+      yield* mergeFile(acc, file)
+    }
+  }
+
+  const result = TuiConfig.resolve(
+    {
+      ...acc.result,
+    },
+    {
+      terminalSuspend: process.platform !== "win32",
+    },
+  )
+
+  return {
+    config: result,
+    pluginOrigins: acc.plugin_origins,
+    dirs: result.plugin?.length ? dirs : [],
+  }
+})
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const directory = yield* CurrentWorkingDirectory
+    const npm = yield* Npm.Service
+    const data = yield* loadState({ directory })
+    const deps = yield* Effect.forEach(
+      data.dirs,
+      (dir) =>
+        npm
+          .install(dir, {
+            add: [
+              {
+                name: "@miaw/plugin",
+                version: InstallationLocal ? undefined : InstallationVersion,
+              },
+            ],
+          })
+          .pipe(Effect.forkScoped),
+      {
+        concurrency: "unbounded",
+      },
+    )
+
+    const get = Effect.fn("TuiConfig.get")(() => Effect.succeed(data.config))
+    const pluginOrigins = Effect.fn("TuiConfig.pluginOrigins")(() => Effect.succeed(data.pluginOrigins))
+
+    const waitForDependencies = Effect.fn("TuiConfig.waitForDependencies")(() =>
+      Effect.forEach(deps, Fiber.join, { concurrency: "unbounded" }).pipe(Effect.ignore(), Effect.asVoid),
+    )
+    return Service.of({ get, pluginOrigins, waitForDependencies })
+  }).pipe(Effect.withSpan("TuiConfig.layer")),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Npm.defaultLayer), Layer.provide(FSUtil.defaultLayer))
+
+const { runPromise } = makeRuntime(Service, defaultLayer)
+
+export async function waitForDependencies() {
+  await runPromise((svc) => svc.waitForDependencies())
+}
+
+export async function get() {
+  return runPromise((svc) => svc.get())
+}
+
+export async function pluginOrigins() {
+  return runPromise((svc) => svc.pluginOrigins())
+}

package/src/config/variable.ts

@@ -0,0 +1,91 @@
+export * as ConfigVariable from "./variable"
+
+import path from "path"
+import os from "os"
+import { Filesystem } from "@/util/filesystem"
+import { InvalidError } from "@miaw/core/v1/config/error"
+
+type ParseSource =
+  | {
+      type: "path"
+      path: string
+    }
+  | {
+      type: "virtual"
+      source: string
+      dir: string
+    }
+
+type SubstituteInput = ParseSource & {
+  text: string
+  missing?: "error" | "empty"
+  env?: Record<string, string>
+}
+
+function source(input: ParseSource) {
+  return input.type === "path" ? input.path : input.source
+}
+
+function dir(input: ParseSource) {
+  return input.type === "path" ? path.dirname(input.path) : input.dir
+}
+
+/** Apply {env:VAR} and {file:path} substitutions to config text. */
+export async function substitute(input: SubstituteInput) {
+  const missing = input.missing ?? "error"
+  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
+    return (input.env?.[varName] ?? process.env[varName]) || ""
+  })
+
+  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
+  if (!fileMatches.length) return text
+
+  const configDir = dir(input)
+  const configSource = source(input)
+  let out = ""
+  let cursor = 0
+
+  for (const match of fileMatches) {
+    const token = match[0]
+    const index = match.index
+    out += text.slice(cursor, index)
+
+    const lineStart = text.lastIndexOf("\n", index - 1) + 1
+    const prefix = text.slice(lineStart, index).trimStart()
+    if (prefix.startsWith("//")) {
+      out += token
+      cursor = index + token.length
+      continue
+    }
+
+    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
+    if (filePath.startsWith("~/")) {
+      filePath = path.join(os.homedir(), filePath.slice(2))
+    }
+
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
+    const fileContent = (
+      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
+        if (missing === "empty") return ""
+
+        const errMsg = `bad file reference: "${token}"`
+        if (error.code === "ENOENT") {
+          throw new InvalidError(
+            {
+              path: configSource,
+              message: errMsg + ` ${resolvedPath} does not exist`,
+            },
+            { cause: error },
+          )
+        }
+        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
+      })
+    ).trim()
+
+    out += JSON.stringify(fileContent).slice(1, -1)
+    cursor = index + token.length
+  }
+
+  out += text.slice(cursor)
+  return out
+}

package/src/control-plane/adapters/index.ts

@@ -0,0 +1,41 @@
+import type { ProjectV2 } from "@miaw/core/project"
+import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
+import { WorktreeAdapter } from "./worktree"
+
+const BUILTIN: Record<string, WorkspaceAdapter> = {
+  worktree: WorktreeAdapter,
+}
+
+const state = new Map<ProjectV2.ID, Map<string, WorkspaceAdapter>>()
+
+export function getAdapter(projectID: ProjectV2.ID, type: string): WorkspaceAdapter {
+  const custom = state.get(projectID)?.get(type)
+  if (custom) return custom
+
+  const builtin = BUILTIN[type]
+  if (builtin) return builtin
+
+  throw new Error(`Unknown workspace adapter: ${type}`)
+}
+
+export function listAdapters(projectID: ProjectV2.ID): WorkspaceAdapterEntry[] {
+  return registeredAdapters(projectID).map(([type, adapter]) => ({
+    type,
+    name: adapter.name,
+    description: adapter.description,
+  }))
+}
+
+export function registeredAdapters(projectID: ProjectV2.ID): [string, WorkspaceAdapter][] {
+  const adapters = new Map(Object.entries(BUILTIN))
+  for (const [type, adapter] of state.get(projectID)?.entries() ?? []) adapters.set(type, adapter)
+  return [...adapters.entries()]
+}
+
+// Plugins can be loaded per-project so we need to scope them. If you
+// want to install a global one pass `ProjectV2.ID.global`
+export function registerAdapter(projectID: ProjectV2.ID, type: string, adapter: WorkspaceAdapter) {
+  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
+  adapters.set(type, adapter)
+  state.set(projectID, adapters)
+}

package/src/control-plane/adapters/worktree.ts

@@ -0,0 +1,96 @@
+import { Effect, Schema } from "effect"
+import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
+import { type WorkspaceAdapter, type WorkspaceAdapterContext, WorkspaceInfo } from "../types"
+
+const WorktreeConfig = Schema.Struct({
+  name: WorkspaceInfo.fields.name,
+  branch: Schema.optional(Schema.NullOr(Schema.String)),
+  directory: Schema.String,
+})
+const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)
+
+async function loadWorktree() {
+  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
+  return { AppRuntime, Worktree }
+}
+
+function requireInstance(context: WorkspaceAdapterContext | undefined) {
+  if (!context?.instance) throw new Error("Worktree adapter requires an instance context")
+  return context.instance
+}
+
+const provideContext = <A, E, R>(effect: Effect.Effect<A, E, R>, context: WorkspaceAdapterContext | undefined) =>
+  effect.pipe(
+    Effect.provideService(InstanceRef, requireInstance(context)),
+    Effect.provideService(WorkspaceRef, context?.workspaceID),
+  )
+
+export const WorktreeAdapter: WorkspaceAdapter = {
+  name: "Worktree",
+  description: "Create a git worktree",
+  async configure(info, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const next = await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.makeWorktreeInfo({ detached: true })),
+        context,
+      ),
+    )
+    return {
+      ...info,
+      name: next.name,
+      directory: next.directory,
+    }
+  },
+  async create(info, _env, _from, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const config = decodeWorktreeConfig(info)
+    await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) =>
+          svc.createFromInfo({
+            name: config.name,
+            directory: config.directory,
+            ...(config.branch ? { branch: config.branch } : {}),
+          }),
+        ),
+        context,
+      ),
+    )
+  },
+  async list(context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const ctx = requireInstance(context)
+    return (
+      await AppRuntime.runPromise(
+        provideContext(
+          Worktree.Service.use((svc) => svc.list()),
+          context,
+        ),
+      )
+    ).map((info) => ({
+      type: "worktree",
+      name: info.name,
+      branch: info.branch,
+      directory: info.directory,
+      projectID: ctx.project.id,
+    }))
+  },
+  async remove(info, context) {
+    const { AppRuntime, Worktree } = await loadWorktree()
+    const config = decodeWorktreeConfig(info)
+    await AppRuntime.runPromise(
+      provideContext(
+        Worktree.Service.use((svc) => svc.remove({ directory: config.directory })),
+        context,
+      ),
+    )
+  },
+  target(info) {
+    const config = decodeWorktreeConfig(info)
+    return {
+      type: "local",
+      directory: config.directory,
+    }
+  },
+}

package/src/control-plane/dev/README.md

@@ -0,0 +1,19 @@
+This is a plugin to simulate a remote environment locally. Add this to `.miaw/miaw.jsonc`:
+
+```json
+  "plugin": ["../packages/miaw/src/control-plane/dev/debug-workspace-plugin.ts"],
+```
+
+In a separate terminal, run a separate Miaw server. This will act like a remote server and the local instance will proxy all requests to it:
+
+```
+./packages/miaw/script/run-workspace-server
+```
+
+With the plugin install, you can now run Miaw and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
+
+How this works:
+
+- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
+- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
+- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.

package/src/control-plane/dev/debug-workspace-plugin.ts

@@ -0,0 +1,73 @@
+import type { Plugin } from "@miaw/plugin"
+import { rename, writeFile } from "node:fs/promises"
+import { randomInt } from "node:crypto"
+import { setTimeout as sleep } from "node:timers/promises"
+
+const DEV_DATA_FILE = "/tmp/miaw-workspace-dev-data.json"
+const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
+
+async function waitForHealth(port: number) {
+  const url = `http://127.0.0.1:${port}/global/health`
+  const started = Date.now()
+
+  while (Date.now() - started < 30_000) {
+    try {
+      const response = await fetch(url)
+      if (response.ok) {
+        return
+      }
+    } catch {}
+
+    await sleep(250)
+  }
+
+  throw new Error(`Timed out waiting for debug server health check at ${url}`)
+}
+
+let PORT: number | undefined
+
+async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
+  await writeFile(
+    DEV_DATA_TEMP_FILE,
+    JSON.stringify(
+      {
+        port,
+        id,
+        env,
+      },
+      null,
+      2,
+    ),
+  )
+
+  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
+}
+
+export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
+  experimental_workspace.register("debug", {
+    name: "Debug",
+    description: "Create a debugging server",
+    configure(config) {
+      return config
+    },
+    async create(config, env) {
+      const port = randomInt(5000, 9001)
+      PORT = port
+
+      await writeDebugData(port, config.id, env)
+
+      await waitForHealth(port)
+    },
+    async remove(_config) {},
+    target(_config) {
+      return {
+        type: "remote",
+        url: `http://localhost:${PORT!}/`,
+      }
+    },
+  })
+
+  return {}
+}
+
+export default DebugWorkspacePlugin

package/src/control-plane/types.ts

@@ -0,0 +1,59 @@
+import { Schema, Struct } from "effect"
+import { ProjectV2 } from "@miaw/core/project"
+import type { InstanceContext } from "@/project/instance-context"
+import { WorkspaceV2 } from "@miaw/core/workspace"
+import type { DeepMutable } from "@miaw/core/schema"
+
+export const WorkspaceInfo = Schema.Struct({
+  id: WorkspaceV2.ID,
+  type: Schema.String,
+  name: Schema.String,
+  branch: Schema.optional(Schema.NullOr(Schema.String)),
+  directory: Schema.optional(Schema.NullOr(Schema.String)),
+  extra: Schema.optional(Schema.NullOr(Schema.Unknown)),
+  projectID: ProjectV2.ID,
+}).annotate({ identifier: "Workspace" })
+export type WorkspaceInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceInfo>>
+
+export const WorkspaceListedInfo = Schema.Struct(Struct.omit(WorkspaceInfo.fields, ["id"])).annotate({
+  identifier: "WorkspaceListedInfo",
+})
+export type WorkspaceListedInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceListedInfo>>
+
+export const WorkspaceAdapterEntry = Schema.Struct({
+  type: Schema.String,
+  name: Schema.String,
+  description: Schema.String,
+})
+export type WorkspaceAdapterEntry = Schema.Schema.Type<typeof WorkspaceAdapterEntry>
+
+export type Target =
+  | {
+      type: "local"
+      directory: string
+    }
+  | {
+      type: "remote"
+      url: string | URL
+      headers?: HeadersInit
+    }
+
+export type WorkspaceAdapterContext = {
+  readonly instance?: InstanceContext
+  readonly workspaceID?: WorkspaceV2.ID
+}
+
+export type WorkspaceAdapter = {
+  name: string
+  description: string
+  configure(info: WorkspaceInfo, context?: WorkspaceAdapterContext): WorkspaceInfo | Promise<WorkspaceInfo>
+  create(
+    info: WorkspaceInfo,
+    env: Record<string, string | undefined>,
+    from?: WorkspaceInfo,
+    context?: WorkspaceAdapterContext,
+  ): Promise<void>
+  list?(context?: WorkspaceAdapterContext): WorkspaceListedInfo[] | Promise<WorkspaceListedInfo[]>
+  remove(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Promise<void>
+  target(info: WorkspaceInfo, context?: WorkspaceAdapterContext): Target | Promise<Target>
+}

package/src/control-plane/util.ts

@@ -0,0 +1,39 @@
+import { GlobalBus, type GlobalEvent } from "@/bus/global"
+import { Effect } from "effect"
+
+export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (event: GlobalEvent) => boolean }) {
+  if (input.signal?.aborted) return Effect.fail(input.signal.reason ?? new Error("Request aborted"))
+
+  return Effect.callback<void, unknown>((resume) => {
+    const abort = () => {
+      cleanup()
+      resume(Effect.fail(input.signal?.reason ?? new Error("Request aborted")))
+    }
+
+    const handler = (event: GlobalEvent) => {
+      try {
+        if (!input.fn(event)) return
+        cleanup()
+        resume(Effect.void)
+      } catch (error) {
+        cleanup()
+        resume(Effect.fail(error))
+      }
+    }
+
+    const cleanup = () => {
+      clearTimeout(timeout)
+      GlobalBus.off("event", handler)
+      input.signal?.removeEventListener("abort", abort)
+    }
+
+    const timeout = setTimeout(() => {
+      cleanup()
+      resume(Effect.fail(new Error("Timed out waiting for global event")))
+    }, input.timeout)
+
+    GlobalBus.on("event", handler)
+    input.signal?.addEventListener("abort", abort, { once: true })
+    return Effect.sync(cleanup)
+  })
+}