fix(app): terminal rename from context menu (#18263)

Co-authored-by: Brendan Allan <brendonovich@outlook.com>

packages/app/e2e/terminal/terminal-tabs.spec.ts

@@ -1,7 +1,7 @@
 import type { Page } from "@playwright/test"
 import { runTerminal, waitTerminalReady } from "../actions"
 import { test, expect } from "../fixtures"
-import { terminalSelector } from "../selectors"
+import { dropdownMenuContentSelector, terminalSelector } from "../selectors"
 import { terminalToggleKey, workspacePersistKey } from "../utils"
 
 type State = {
@@ -130,3 +130,39 @@ test("closing the active terminal tab falls back to the previous tab", async ({
       .toEqual({ count: 1, first: true })
   })
 })
+
+test("terminal tab can be renamed from the context menu", async ({ page, withProject }) => {
+  await withProject(async ({ directory, gotoSession }) => {
+    const key = workspacePersistKey(directory, "terminal")
+    const rename = `E2E term ${Date.now()}`
+    const tab = page.locator('#terminal-panel [data-slot="tabs-trigger"]').first()
+
+    await gotoSession()
+    await open(page)
+
+    await expect(tab).toContainText(/Terminal 1/)
+    await tab.click({ button: "right" })
+
+    const menu = page.locator(dropdownMenuContentSelector).first()
+    await expect(menu).toBeVisible()
+    await menu.getByRole("menuitem", { name: /^Rename$/i }).click()
+    await expect(menu).toHaveCount(0)
+
+    const input = page.locator('#terminal-panel input[type="text"]').first()
+    await expect(input).toBeVisible()
+    await input.fill(rename)
+    await input.press("Enter")
+
+    await expect(input).toHaveCount(0)
+    await expect(tab).toContainText(rename)
+    await expect
+      .poll(
+        async () => {
+          const state = await store(page, key)
+          return state?.all[0]?.title
+        },
+        { timeout: 5_000 },
+      )
+      .toBe(rename)
+  })
+})

packages/app/src/components/session/session-sortable-terminal-tab.tsx

@@ -24,6 +24,7 @@ export function SortableTerminalTab(props: { terminal: LocalPTY; onClose?: () =>
   })
   let input: HTMLInputElement | undefined
   let blurFrame: number | undefined
+  let editRequested = false
 
   const isDefaultTitle = () => {
     const number = props.terminal.titleNumber
@@ -168,8 +169,14 @@ export function SortableTerminalTab(props: { terminal: LocalPTY; onClose?: () =>
                 left: `${store.menuPosition.x}px`,
                 top: `${store.menuPosition.y}px`,
               }}
+              onCloseAutoFocus={(e) => {
+                if (!editRequested) return
+                e.preventDefault()
+                editRequested = false
+                requestAnimationFrame(() => edit())
+              }}
             >
-              <DropdownMenu.Item onSelect={edit}>
+              <DropdownMenu.Item onSelect={() => (editRequested = true)}>
                 <Icon name="edit" class="w-4 h-4 mr-2" />
                 {language.t("common.rename")}
               </DropdownMenu.Item>

packages/opencode/specs/effect-migration.md

@@ -6,7 +6,7 @@ Practical reference for new and migrated Effect code in `packages/opencode`.
 
 Use `InstanceState` (from `src/effect/instance-state.ts`) for services that need per-directory state, per-instance cleanup, or project-bound background work. InstanceState uses a `ScopedCache` keyed by directory, so each open project gets its own copy of the state that is automatically cleaned up on disposal.
 
-Use `makeRuntime` (from `src/effect/run-service.ts`) to create a per-service `ManagedRuntime` that lazily initializes and shares layers via a global `memoMap`. Returns `{ runPromise, runFork }`.
+Use `makeRunPromise` (from `src/effect/run-service.ts`) to create a per-service `ManagedRuntime` that lazily initializes and shares layers via a global `memoMap`.
 
 - Global services (no per-directory state): Account, Auth, Installation, Truncate
 - Instance-scoped (per-directory state via InstanceState): File, FileTime, FileWatcher, Format, Permission, Question, Skill, Snapshot, Vcs, ProviderAuth
@@ -46,7 +46,7 @@ export namespace Foo {
   export const defaultLayer = layer.pipe(Layer.provide(FooDep.layer))
 
   // Per-service runtime (inside the namespace)
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   // Async facade functions
   export async function get(id: FooID) {

packages/opencode/src/account/index.ts

@@ -1,7 +1,7 @@
 import { Clock, Duration, Effect, Layer, Option, Schema, SchemaGetter, ServiceMap } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { withTransientReadRetry } from "@/util/effect-http-client"
 import { AccountRepo, type AccountRow } from "./repo"
 import {
@@ -379,7 +379,7 @@ export namespace Account {
 
   export const defaultLayer = layer.pipe(Layer.provide(AccountRepo.layer), Layer.provide(FetchHttpClient.layer))
 
-  export const { runPromise } = makeRuntime(Service, defaultLayer)
+  export const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function active(): Promise<Info | undefined> {
     return Option.getOrUndefined(await runPromise((service) => service.active()))

packages/opencode/src/auth/index.ts

@@ -1,6 +1,6 @@
 import path from "path"
 import { Effect, Layer, Record, Result, Schema, ServiceMap } from "effect"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { zod } from "@/util/effect-zod"
 import { Global } from "../global"
 import { Filesystem } from "../util/filesystem"
@@ -95,7 +95,7 @@ export namespace Auth {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function get(providerID: string) {
     return runPromise((service) => service.get(providerID))

packages/opencode/src/bus/index.ts

@@ -1,14 +1,12 @@
 import z from "zod"
-import { Effect, Layer, PubSub, ServiceMap, Stream } from "effect"
 import { Log } from "../util/log"
 import { Instance } from "../project/instance"
 import { BusEvent } from "./bus-event"
 import { GlobalBus } from "./global"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
 
 export namespace Bus {
   const log = Log.create({ service: "bus" })
+  type Subscription = (event: any) => void
 
   export const InstanceDisposed = BusEvent.define(
     "server.instance.disposed",
@@ -17,129 +15,91 @@ export namespace Bus {
     }),
   )
 
-  type Payload<D extends BusEvent.Definition = BusEvent.Definition> = {
-    type: D["type"]
-    properties: z.infer<D["properties"]>
-  }
+  const state = Instance.state(
+    () => {
+      const subscriptions = new Map<any, Subscription[]>()
 
-  type State = {
-    wildcard: PubSub.PubSub<Payload>
-    typed: Map<string, PubSub.PubSub<Payload>>
-  }
-
-  export interface Interface {
-    readonly publish: <D extends BusEvent.Definition>(
-      def: D,
-      properties: z.output<D["properties"]>,
-    ) => Effect.Effect<void>
-    readonly subscribe: <D extends BusEvent.Definition>(def: D) => Stream.Stream<Payload<D>>
-    readonly subscribeAll: () => Stream.Stream<Payload>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Bus") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const cache = yield* InstanceState.make<State>(
-        Effect.fn("Bus.state")(function* (ctx) {
-          const wildcard = yield* PubSub.unbounded<Payload>()
-          const typed = new Map<string, PubSub.PubSub<Payload>>()
-
-          yield* Effect.addFinalizer(() =>
-            Effect.gen(function* () {
-              // Publish InstanceDisposed before shutting down so subscribers see it
-              yield* PubSub.publish(wildcard, {
-                type: InstanceDisposed.type,
-                properties: { directory: ctx.directory },
-              })
-              yield* PubSub.shutdown(wildcard)
-              for (const ps of typed.values()) {
-                yield* PubSub.shutdown(ps)
-              }
-            }),
-          )
-
-          return { wildcard, typed }
-        }),
-      )
-
-      function getOrCreate(state: State, type: string) {
-        return Effect.gen(function* () {
-          let ps = state.typed.get(type)
-          if (!ps) {
-            ps = yield* PubSub.unbounded<Payload>()
-            state.typed.set(type, ps)
-          }
-          return ps
-        })
+      return {
+        subscriptions,
       }
-
-      function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
-        return Effect.gen(function* () {
-          const state = yield* InstanceState.get(cache)
-          const payload: Payload = { type: def.type, properties }
-          log.info("publishing", { type: def.type })
-
-          const ps = state.typed.get(def.type)
-          if (ps) yield* PubSub.publish(ps, payload)
-          yield* PubSub.publish(state.wildcard, payload)
-
-          GlobalBus.emit("event", {
-            directory: Instance.directory,
-            payload,
-          })
-        })
+    },
+    async (entry) => {
+      const wildcard = entry.subscriptions.get("*")
+      if (!wildcard) return
+      const event = {
+        type: InstanceDisposed.type,
+        properties: {
+          directory: Instance.directory,
+        },
       }
-
-      function subscribe<D extends BusEvent.Definition>(def: D): Stream.Stream<Payload<D>> {
-        log.info("subscribing", { type: def.type })
-        return Stream.unwrap(
-          Effect.gen(function* () {
-            const state = yield* InstanceState.get(cache)
-            const ps = yield* getOrCreate(state, def.type)
-            return Stream.fromPubSub(ps) as Stream.Stream<Payload<D>>
-          }),
-        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: def.type }))))
+      for (const sub of [...wildcard]) {
+        sub(event)
       }
-
-      function subscribeAll(): Stream.Stream<Payload> {
-        log.info("subscribing", { type: "*" })
-        return Stream.unwrap(
-          Effect.gen(function* () {
-            const state = yield* InstanceState.get(cache)
-            return Stream.fromPubSub(state.wildcard)
-          }),
-        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: "*" }))))
-      }
-
-      return Service.of({ publish, subscribe, subscribeAll })
-    }),
+    },
   )
 
-  const { runPromise, runCallback } = makeRuntime(Service, layer)
-
-  function forkStream<T>(streamFn: (svc: Interface) => Stream.Stream<T>, callback: (msg: T) => void) {
-    return runCallback((svc) =>
-      streamFn(svc).pipe(Stream.runForEach((msg) => Effect.sync(() => callback(msg)))),
-    )
+  export async function publish<Definition extends BusEvent.Definition>(
+    def: Definition,
+    properties: z.output<Definition["properties"]>,
+  ) {
+    const payload = {
+      type: def.type,
+      properties,
+    }
+    log.info("publishing", {
+      type: def.type,
+    })
+    const pending = []
+    for (const key of [def.type, "*"]) {
+      const match = [...(state().subscriptions.get(key) ?? [])]
+      for (const sub of match) {
+        pending.push(sub(payload))
+      }
+    }
+    GlobalBus.emit("event", {
+      directory: Instance.directory,
+      payload,
+    })
+    return Promise.all(pending)
   }
 
-  export async function publish<D extends BusEvent.Definition>(
-    def: D,
-    properties: z.output<D["properties"]>,
+  export function subscribe<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
   ) {
-    return runPromise((svc) => svc.publish(def, properties))
+    return raw(def.type, callback)
   }
 
-  export function subscribe<D extends BusEvent.Definition>(
-    def: D,
-    callback: (event: { type: D["type"]; properties: z.infer<D["properties"]> }) => void,
+  export function once<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: {
+      type: Definition["type"]
+      properties: z.infer<Definition["properties"]>
+    }) => "done" | undefined,
   ) {
-    return forkStream((svc) => svc.subscribe(def), callback)
+    const unsub = subscribe(def, (event) => {
+      if (callback(event)) unsub()
+    })
   }
 
   export function subscribeAll(callback: (event: any) => void) {
-    return forkStream((svc) => svc.subscribeAll(), callback)
+    return raw("*", callback)
+  }
+
+  function raw(type: string, callback: (event: any) => void) {
+    log.info("subscribing", { type })
+    const subscriptions = state().subscriptions
+    let match = subscriptions.get(type) ?? []
+    match.push(callback)
+    subscriptions.set(type, match)
+
+    return () => {
+      log.info("unsubscribing", { type })
+      const match = subscriptions.get(type)
+      if (!match) return
+      const index = match.indexOf(callback)
+      if (index === -1) return
+      match.splice(index, 1)
+    }
   }
 }

packages/opencode/src/command/index.ts

@@ -1,6 +1,6 @@
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { SessionID, MessageID } from "@/session/schema"
 import { Effect, Layer, ServiceMap } from "effect"
 import z from "zod"
@@ -173,7 +173,7 @@ export namespace Command {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function get(name: string) {
     return runPromise((svc) => svc.get(name))

packages/opencode/src/effect/run-service.ts

@@ -3,16 +3,11 @@ import * as ServiceMap from "effect/ServiceMap"
 
 export const memoMap = Layer.makeMemoMapUnsafe()
 
-export function makeRuntime<I, S, E>(service: ServiceMap.Service<I, S>, layer: Layer.Layer<I, E>) {
+export function makeRunPromise<I, S, E>(service: ServiceMap.Service<I, S>, layer: Layer.Layer<I, E>) {
   let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
-  const getRuntime = () => (rt ??= ManagedRuntime.make(layer, { memoMap }))
 
-  return {
-    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
-      getRuntime().runPromise(service.use(fn), options),
-    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runFork(service.use(fn)),
-    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) =>
-      getRuntime().runCallback(service.use(fn)),
+  return <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => {
+    rt ??= ManagedRuntime.make(layer, { memoMap })
+    return rt.runPromise(service.use(fn), options)
   }
 }
-

packages/opencode/src/file/index.ts

@@ -1,6 +1,6 @@
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { git } from "@/util/git"
 import { Effect, Fiber, Layer, Scope, ServiceMap } from "effect"
 import { formatPatch, structuredPatch } from "diff"
@@ -688,7 +688,7 @@ export namespace File {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export function init() {
     return runPromise((svc) => svc.init())

packages/opencode/src/file/time.ts

@@ -1,6 +1,6 @@
 import { DateTime, Effect, Layer, Semaphore, ServiceMap } from "effect"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import type { SessionID } from "@/session/schema"
 import { Filesystem } from "../util/filesystem"
@@ -108,7 +108,7 @@ export namespace FileTime {
     }),
   ).pipe(Layer.orDie)
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export function read(sessionID: SessionID, file: string) {
     return runPromise((s) => s.read(sessionID, file))

packages/opencode/src/file/watcher.ts

@@ -8,7 +8,7 @@ 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 { makeRunPromise } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { Instance } from "@/project/instance"
 import { git } from "@/util/git"
@@ -159,7 +159,7 @@ export namespace FileWatcher {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export function init() {
     return runPromise((svc) => svc.init())

packages/opencode/src/format/index.ts

@@ -1,10 +1,12 @@
 import { Effect, Layer, ServiceMap } from "effect"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import path from "path"
 import { mergeDeep } from "remeda"
 import z from "zod"
+import { Bus } from "../bus"
 import { Config } from "../config/config"
+import { File } from "../file"
 import { Instance } from "../project/instance"
 import { Process } from "../util/process"
 import { Log } from "../util/log"
@@ -27,7 +29,6 @@ export namespace Format {
   export interface Interface {
     readonly init: () => Effect.Effect<void>
     readonly status: () => Effect.Effect<Status[]>
-    readonly file: (filepath: string) => Effect.Effect<void>
   }
 
   export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Format") {}
@@ -96,46 +97,53 @@ export namespace Format {
             return checks.filter((x) => x.enabled).map((x) => x.item)
           }
 
-          async function formatFile(filepath: string) {
-            log.info("formatting", { file: filepath })
-            const ext = path.extname(filepath)
-
-            for (const item of await getFormatter(ext)) {
-              log.info("running", { command: item.command })
-              try {
-                const proc = Process.spawn(
-                  item.command.map((x) => x.replace("$FILE", filepath)),
-                  {
-                    cwd: Instance.directory,
-                    env: { ...process.env, ...item.environment },
-                    stdout: "ignore",
-                    stderr: "ignore",
-                  },
-                )
-                const exit = await proc.exited
-                if (exit !== 0) {
-                  log.error("failed", {
-                    command: item.command,
-                    ...item.environment,
-                  })
-                }
-              } catch (error) {
-                log.error("failed to format file", {
-                  error,
-                  command: item.command,
-                  ...item.environment,
-                  file: filepath,
-                })
-              }
-            }
-          }
+          yield* Effect.acquireRelease(
+            Effect.sync(() =>
+              Bus.subscribe(
+                File.Event.Edited,
+                Instance.bind(async (payload) => {
+                  const file = payload.properties.file
+                  log.info("formatting", { file })
+                  const ext = path.extname(file)
 
+                  for (const item of await getFormatter(ext)) {
+                    log.info("running", { command: item.command })
+                    try {
+                      const proc = Process.spawn(
+                        item.command.map((x) => x.replace("$FILE", file)),
+                        {
+                          cwd: Instance.directory,
+                          env: { ...process.env, ...item.environment },
+                          stdout: "ignore",
+                          stderr: "ignore",
+                        },
+                      )
+                      const exit = await proc.exited
+                      if (exit !== 0) {
+                        log.error("failed", {
+                          command: item.command,
+                          ...item.environment,
+                        })
+                      }
+                    } catch (error) {
+                      log.error("failed to format file", {
+                        error,
+                        command: item.command,
+                        ...item.environment,
+                        file,
+                      })
+                    }
+                  }
+                }),
+              ),
+            ),
+            (unsubscribe) => Effect.sync(unsubscribe),
+          )
           log.info("init")
 
           return {
             formatters,
             isEnabled,
-            formatFile,
           }
         }),
       )
@@ -158,16 +166,11 @@ export namespace Format {
         return result
       })
 
-      const file = Effect.fn("Format.file")(function* (filepath: string) {
-        const { formatFile } = yield* InstanceState.get(state)
-        yield* Effect.promise(() => formatFile(filepath))
-      })
-
-      return Service.of({ init, status, file })
+      return Service.of({ init, status })
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function init() {
     return runPromise((s) => s.init())
@@ -176,8 +179,4 @@ export namespace Format {
   export async function status() {
     return runPromise((s) => s.status())
   }
-
-  export async function file(filepath: string) {
-    return runPromise((s) => s.file(filepath))
-  }
 }

packages/opencode/src/installation/index.ts

@@ -1,7 +1,7 @@
 import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node"
 import { Effect, Layer, Schema, ServiceMap, Stream } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { withTransientReadRetry } from "@/util/effect-http-client"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import path from "path"
@@ -330,7 +330,7 @@ export namespace Installation {
     Layer.provide(NodePath.layer),
   )
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function info(): Promise<Info> {
     return runPromise((svc) => svc.info())

packages/opencode/src/permission/index.ts

@@ -2,7 +2,7 @@ import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { Config } from "@/config/config"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { ProjectID } from "@/project/schema"
 import { Instance } from "@/project/instance"
 import { MessageID, SessionID } from "@/session/schema"
@@ -306,7 +306,7 @@ export namespace Permission {
     return result
   }
 
-  export const { runPromise } = makeRuntime(Service, layer)
+  export const runPromise = makeRunPromise(Service, layer)
 
   export async function ask(input: z.infer<typeof AskInput>) {
     return runPromise((s) => s.ask(input))

packages/opencode/src/plugin/index.ts

@@ -13,7 +13,7 @@ import { CopilotAuthPlugin } from "./copilot"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
 import { Effect, Layer, ServiceMap } from "effect"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 
 export namespace Plugin {
   const log = Log.create({ service: "plugin" })
@@ -186,7 +186,7 @@ export namespace Plugin {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function trigger<
     Name extends TriggerName,

packages/opencode/src/project/vcs.ts

@@ -2,7 +2,7 @@ import { Effect, Layer, ServiceMap } from "effect"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { FileWatcher } from "@/file/watcher"
 import { Log } from "@/util/log"
 import { git } from "@/util/git"
@@ -99,7 +99,7 @@ export namespace Vcs {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export function init() {
     return runPromise((svc) => svc.init())

packages/opencode/src/provider/auth.ts

@@ -2,7 +2,7 @@ import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
 import { NamedError } from "@opencode-ai/util/error"
 import { Auth } from "@/auth"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { Plugin } from "../plugin"
 import { ProviderID } from "./schema"
 import { Array as Arr, Effect, Layer, Record, Result, ServiceMap } from "effect"
@@ -231,7 +231,7 @@ export namespace ProviderAuth {
 
   export const defaultLayer = layer.pipe(Layer.provide(Auth.layer))
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function methods() {
     return runPromise((svc) => svc.methods())

packages/opencode/src/pty/index.ts

@@ -1,7 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { Instance } from "@/project/instance"
 import { type IPty } from "bun-pty"
 import z from "zod"
@@ -361,7 +361,7 @@ export namespace Pty {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function list() {
     return runPromise((svc) => svc.list())

packages/opencode/src/question/index.ts

@@ -2,7 +2,7 @@ import { Deferred, Effect, Layer, Schema, ServiceMap } from "effect"
 import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { SessionID, MessageID } from "@/session/schema"
 import { Log } from "@/util/log"
 import z from "zod"
@@ -197,7 +197,7 @@ export namespace Question {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function ask(input: {
     sessionID: SessionID

packages/opencode/src/session/status.ts

@@ -1,7 +1,7 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { SessionID } from "./schema"
 import { Effect, Layer, ServiceMap } from "effect"
 import z from "zod"
@@ -83,7 +83,7 @@ export namespace SessionStatus {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function get(sessionID: SessionID) {
     return runPromise((svc) => svc.get(sessionID))

packages/opencode/src/skill/index.ts

@@ -7,7 +7,7 @@ import { NamedError } from "@opencode-ai/util/error"
 import type { Agent } from "@/agent/agent"
 import { Bus } from "@/bus"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { Flag } from "@/flag/flag"
 import { Global } from "@/global"
 import { Permission } from "@/permission"
@@ -242,7 +242,7 @@ export namespace Skill {
     return ["## Available Skills", ...list.map((skill) => `- **${skill.name}**: ${skill.description}`)].join("\n")
   }
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function get(name: string) {
     return runPromise((skill) => skill.get(name))

packages/opencode/src/snapshot/index.ts

@@ -4,7 +4,7 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import path from "path"
 import z from "zod"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { Config } from "../config/config"
 import { Global } from "../global"
@@ -360,7 +360,7 @@ export namespace Snapshot {
     Layer.provide(NodePath.layer),
   )
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function init() {
     return runPromise((svc) => svc.init())

packages/opencode/src/tool/apply_patch.ts

@@ -12,7 +12,7 @@ import { trimDiff } from "./edit"
 import { LSP } from "../lsp"
 import { Filesystem } from "../util/filesystem"
 import DESCRIPTION from "./apply_patch.txt"
-import { Format } from "../format"
+import { File } from "../file"
 
 const PatchParams = z.object({
   patchText: z.string().describe("The full patch text that describes all changes to be made"),
@@ -220,7 +220,9 @@ export const ApplyPatchTool = Tool.define("apply_patch", {
       }
 
       if (edited) {
-        await Format.file(edited)
+        await Bus.publish(File.Event.Edited, {
+          file: edited,
+        })
       }
     }
 

packages/opencode/src/tool/edit.ts

@@ -9,9 +9,9 @@ import { Tool } from "./tool"
 import { LSP } from "../lsp"
 import { createTwoFilesPatch, diffLines } from "diff"
 import DESCRIPTION from "./edit.txt"
+import { File } from "../file"
 import { FileWatcher } from "../file/watcher"
 import { Bus } from "../bus"
-import { Format } from "../format"
 import { FileTime } from "../file/time"
 import { Filesystem } from "../util/filesystem"
 import { Instance } from "../project/instance"
@@ -71,7 +71,9 @@ export const EditTool = Tool.define("edit", {
           },
         })
         await Filesystem.write(filePath, params.newString)
-        await Format.file(filePath)
+        await Bus.publish(File.Event.Edited, {
+          file: filePath,
+        })
         await Bus.publish(FileWatcher.Event.Updated, {
           file: filePath,
           event: existed ? "change" : "add",
@@ -106,7 +108,9 @@ export const EditTool = Tool.define("edit", {
       })
 
       await Filesystem.write(filePath, contentNew)
-      await Format.file(filePath)
+      await Bus.publish(File.Event.Edited, {
+        file: filePath,
+      })
       await Bus.publish(FileWatcher.Event.Updated, {
         file: filePath,
         event: "change",

packages/opencode/src/tool/registry.ts

@@ -31,7 +31,7 @@ import { Glob } from "../util/glob"
 import { pathToFileURL } from "url"
 import { Effect, Layer, ServiceMap } from "effect"
 import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 
 export namespace ToolRegistry {
   const log = Log.create({ service: "tool.registry" })
@@ -198,7 +198,7 @@ export namespace ToolRegistry {
     }),
   )
 
-  const { runPromise } = makeRuntime(Service, layer)
+  const runPromise = makeRunPromise(Service, layer)
 
   export async function register(tool: Tool.Info) {
     return runPromise((svc) => svc.register(tool))

packages/opencode/src/tool/truncate.ts

@@ -2,7 +2,7 @@ import { NodePath } from "@effect/platform-node"
 import { Cause, Duration, Effect, Layer, Schedule, ServiceMap } from "effect"
 import path from "path"
 import type { Agent } from "../agent/agent"
-import { makeRuntime } from "@/effect/run-service"
+import { makeRunPromise } from "@/effect/run-service"
 import { AppFileSystem } from "@/filesystem"
 import { evaluate } from "@/permission/evaluate"
 import { Identifier } from "../id/id"
@@ -136,7 +136,7 @@ export namespace Truncate {
 
   export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
 
-  const { runPromise } = makeRuntime(Service, defaultLayer)
+  const runPromise = makeRunPromise(Service, defaultLayer)
 
   export async function output(text: string, options: Options = {}, agent?: Agent.Info): Promise<Result> {
     return runPromise((s) => s.output(text, options, agent))

packages/opencode/src/tool/write.ts

@@ -5,8 +5,8 @@ import { LSP } from "../lsp"
 import { createTwoFilesPatch } from "diff"
 import DESCRIPTION from "./write.txt"
 import { Bus } from "../bus"
+import { File } from "../file"
 import { FileWatcher } from "../file/watcher"
-import { Format } from "../format"
 import { FileTime } from "../file/time"
 import { Filesystem } from "../util/filesystem"
 import { Instance } from "../project/instance"
@@ -42,7 +42,9 @@ export const WriteTool = Tool.define("write", {
     })
 
     await Filesystem.write(filepath, params.content)
-    await Format.file(filepath)
+    await Bus.publish(File.Event.Edited, {
+      file: filepath,
+    })
     await Bus.publish(FileWatcher.Event.Updated, {
       file: filepath,
       event: exists ? "change" : "add",

packages/opencode/test/bus/bus.test.ts

@@ -1,181 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import z from "zod"
-import { Bus } from "../../src/bus"
-import { BusEvent } from "../../src/bus/bus-event"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-
-const TestEvent = {
-  Ping: BusEvent.define("test.ping", z.object({ value: z.number() })),
-  Pong: BusEvent.define("test.pong", z.object({ message: z.string() })),
-}
-
-function withInstance(directory: string, fn: () => Promise<void>) {
-  return Instance.provide({ directory, fn })
-}
-
-describe("Bus", () => {
-  afterEach(() => Instance.disposeAll())
-
-  describe("publish + subscribe", () => {
-    test("subscriber receives matching events", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          received.push(evt.properties.value)
-        })
-        // Give the subscriber fiber time to start consuming
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 42 })
-        await Bus.publish(TestEvent.Ping, { value: 99 })
-        // Give subscriber time to process
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual([42, 99])
-    })
-
-    test("subscriber does not receive events of other types", async () => {
-      await using tmp = await tmpdir()
-      const pings: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => {
-          pings.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Pong, { message: "hello" })
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      expect(pings).toEqual([1])
-    })
-
-    test("publish with no subscribers does not throw", async () => {
-      await using tmp = await tmpdir()
-
-      await withInstance(tmp.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-      })
-    })
-  })
-
-  describe("unsubscribe", () => {
-    test("unsubscribe stops delivery", async () => {
-      await using tmp = await tmpdir()
-      const received: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        const unsub = Bus.subscribe(TestEvent.Ping, (evt) => {
-          received.push(evt.properties.value)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-        unsub()
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toEqual([1])
-    })
-  })
-
-  describe("subscribeAll", () => {
-    test("receives all event types", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bus.publish(TestEvent.Pong, { message: "hi" })
-        await Bun.sleep(10)
-      })
-
-      expect(received).toContain("test.ping")
-      expect(received).toContain("test.pong")
-    })
-  })
-
-  describe("multiple subscribers", () => {
-    test("all subscribers for same event type are called", async () => {
-      await using tmp = await tmpdir()
-      const a: number[] = []
-      const b: number[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => a.push(evt.properties.value))
-        Bus.subscribe(TestEvent.Ping, (evt) => b.push(evt.properties.value))
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 7 })
-        await Bun.sleep(10)
-      })
-
-      expect(a).toEqual([7])
-      expect(b).toEqual([7])
-    })
-  })
-
-  describe("instance isolation", () => {
-    test("events in one directory do not reach subscribers in another", async () => {
-      await using tmpA = await tmpdir()
-      await using tmpB = await tmpdir()
-      const receivedA: number[] = []
-      const receivedB: number[] = []
-
-      await withInstance(tmpA.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => receivedA.push(evt.properties.value))
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpB.path, async () => {
-        Bus.subscribe(TestEvent.Ping, (evt) => receivedB.push(evt.properties.value))
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpA.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      await withInstance(tmpB.path, async () => {
-        await Bus.publish(TestEvent.Ping, { value: 2 })
-        await Bun.sleep(10)
-      })
-
-      expect(receivedA).toEqual([1])
-      expect(receivedB).toEqual([2])
-    })
-  })
-
-  describe("instance disposal", () => {
-    test("InstanceDisposed is delivered to wildcard subscribers before stream ends", async () => {
-      await using tmp = await tmpdir()
-      const received: string[] = []
-
-      await withInstance(tmp.path, async () => {
-        Bus.subscribeAll((evt) => {
-          received.push(evt.type)
-        })
-        await Bun.sleep(10)
-        await Bus.publish(TestEvent.Ping, { value: 1 })
-        await Bun.sleep(10)
-      })
-
-      // Instance.disposeAll triggers the finalizer which publishes InstanceDisposed
-      await Instance.disposeAll()
-      await Bun.sleep(50)
-
-      expect(received).toContain("test.ping")
-      expect(received).toContain(Bus.InstanceDisposed.type)
-    })
-  })
-})

packages/opencode/test/effect/run-service.test.ts

@@ -1,10 +1,10 @@
 import { expect, test } from "bun:test"
 import { Effect, Layer, ServiceMap } from "effect"
-import { makeRuntime } from "../../src/effect/run-service"
+import { makeRunPromise } from "../../src/effect/run-service"
 
 class Shared extends ServiceMap.Service<Shared, { readonly id: number }>()("@test/Shared") {}
 
-test("makeRuntime shares dependent layers through the shared memo map", async () => {
+test("makeRunPromise shares dependent layers through the shared memo map", async () => {
   let n = 0
 
   const shared = Layer.effect(
@@ -37,8 +37,8 @@ test("makeRuntime shares dependent layers through the shared memo map", async ()
     }),
   ).pipe(Layer.provide(shared))
 
-  const { runPromise: runOne } = makeRuntime(One, one)
-  const { runPromise: runTwo } = makeRuntime(Two, two)
+  const runOne = makeRunPromise(One, one)
+  const runTwo = makeRunPromise(Two, two)
 
   expect(await runOne((svc) => svc.get())).toBe(1)
   expect(await runTwo((svc) => svc.get())).toBe(1)

packages/opencode/test/format/format.test.ts

@@ -129,7 +129,7 @@ describe("Format", () => {
     try {
       await withServices(tmp.path, Format.layer, async (rt) => {
         await rt.runPromise(Format.Service.use((s) => s.init()))
-        await rt.runPromise(Format.Service.use((s) => s.file(file)))
+        await Bus.publish(File.Event.Edited, { file })
       })
     } finally {
       Formatter.gofmt.extensions = one.extensions
@@ -164,7 +164,7 @@ describe("Format", () => {
 
     await withServices(tmp.path, Format.layer, async (rt) => {
       await rt.runPromise(Format.Service.use((s) => s.init()))
-      await rt.runPromise(Format.Service.use((s) => s.file(file)))
+      await Bus.publish(File.Event.Edited, { file })
     })
 
     expect(await Bun.file(file).text()).toBe("xAB")

packages/opencode/test/tool/edit.test.ts

@@ -89,6 +89,7 @@ describe("tool.edit", () => {
           const { FileWatcher } = await import("../../src/file/watcher")
 
           const events: string[] = []
+          const unsubEdited = Bus.subscribe(File.Event.Edited, () => events.push("edited"))
           const unsubUpdated = Bus.subscribe(FileWatcher.Event.Updated, () => events.push("updated"))
 
           const edit = await EditTool.init()
@@ -101,7 +102,9 @@ describe("tool.edit", () => {
             ctx,
           )
 
+          expect(events).toContain("edited")
           expect(events).toContain("updated")
+          unsubEdited()
           unsubUpdated()
         },
       })
@@ -302,9 +305,11 @@ describe("tool.edit", () => {
           await FileTime.read(ctx.sessionID, filepath)
 
           const { Bus } = await import("../../src/bus")
+          const { File } = await import("../../src/file")
           const { FileWatcher } = await import("../../src/file/watcher")
 
           const events: string[] = []
+          const unsubEdited = Bus.subscribe(File.Event.Edited, () => events.push("edited"))
           const unsubUpdated = Bus.subscribe(FileWatcher.Event.Updated, () => events.push("updated"))
 
           const edit = await EditTool.init()
@@ -317,7 +322,9 @@ describe("tool.edit", () => {
             ctx,
           )
 
+          expect(events).toContain("edited")
           expect(events).toContain("updated")
+          unsubEdited()
           unsubUpdated()
         },
       })