fix(tui): paste into custom form answers

packages/cli/src/server-process.ts

@@ -1,17 +1,17 @@
 export * as ServerProcess from "./server-process"
 
 import { NodeServices } from "@effect/platform-node"
-import { Service, type DiscoverOptions } from "@opencode-ai/client/effect/service"
+import { Service, type DiscoverOptions, type Info } from "@opencode-ai/client/effect/service"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Global } from "@opencode-ai/util/global"
 import { OPENCODE_CHANNEL, OPENCODE_VERSION } from "./version"
 import { AppProcess } from "@opencode-ai/util/process"
 import { randomBytes, randomUUID } from "node:crypto"
-import { Effect, Option, Redacted, Schedule } from "effect"
+import path from "node:path"
+import { Effect, FileSystem, Option, Redacted, Schedule, Schema } from "effect"
 import { HttpServer } from "effect/unstable/http"
 import { Env } from "./env"
 import { ServiceConfig } from "./services/service-config"
-import { ServiceRegistration } from "./services/service-registration"
 import { Updater } from "./services/updater"
 import { WebUi } from "./services/web-ui"
 
@@ -121,13 +121,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
               onListen: (address, shutdown) =>
                 Effect.gen(function* () {
                   if (!config.password) yield* ServiceConfig.password(password)
-                  return yield* ServiceRegistration.register(
-                    address,
-                    password,
-                    instanceID,
-                    serviceOptions.file,
-                    shutdown,
-                  )
+                  return yield* register(address, password, instanceID, serviceOptions.file, shutdown)
                 }),
             },
         transform,
@@ -164,6 +158,52 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
   )
 })
 
+const infoJson = Schema.fromJsonString(Service.Info)
+const encodeInfo = Schema.encodeEffect(infoJson)
+const decodeInfo = Schema.decodeUnknownEffect(infoJson)
+
+const register = Effect.fnUntraced(function* (
+  address: HttpServer.Address,
+  password: string,
+  id: string,
+  file: string,
+  shutdown: Effect.Effect<void>,
+) {
+  const fs = yield* FileSystem.FileSystem
+  const temp = file + "." + id + ".tmp"
+  yield* fs.makeDirectory(path.dirname(file), { recursive: true })
+  const info = {
+    id,
+    version: OPENCODE_VERSION,
+    url: HttpServer.formatAddress(address),
+    pid: process.pid,
+    password,
+  }
+  const encoded = yield* encodeInfo(info)
+  const current = fs.readFileString(file).pipe(
+    Effect.flatMap(decodeInfo),
+    Effect.orElseSucceed(() => undefined),
+  )
+  const owns = (found: Info | undefined) =>
+    found?.id === info.id &&
+    found.version === info.version &&
+    found.url === info.url &&
+    found.pid === info.pid &&
+    found.password === info.password
+  yield* fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
+  yield* current.pipe(
+    Effect.filterOrFail(owns),
+    Effect.repeat(Schedule.spaced("5 seconds")),
+    Effect.ignore,
+    Effect.andThen(shutdown),
+    Effect.forkScoped,
+  )
+  return current.pipe(
+    Effect.flatMap((found) => (owns(found) ? fs.remove(file) : Effect.void)),
+    Effect.ignore,
+  )
+})
+
 const recognizeIncumbent = Effect.fnUntraced(function* (options: DiscoverOptions, hostname: string, port: number) {
   const found = yield* Service.incumbent({ ...options, url: serviceURL(hostname, port) }).pipe(
     Effect.filterOrFail((value) => value !== undefined),

packages/cli/src/services/service-registration.ts

@@ -1,53 +0,0 @@
-export * as ServiceRegistration from "./service-registration"
-
-import { Service, type Info } from "@opencode-ai/client/effect/service"
-import path from "node:path"
-import { Effect, FileSystem, Schedule, Schema } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { OPENCODE_VERSION } from "../version"
-
-const infoJson = Schema.fromJsonString(Service.Info)
-const encodeInfo = Schema.encodeEffect(infoJson)
-const decodeInfo = Schema.decodeUnknownEffect(infoJson)
-
-export const register = Effect.fnUntraced(function* (
-  address: HttpServer.Address,
-  password: string,
-  id: string,
-  file: string,
-  shutdown: Effect.Effect<void>,
-) {
-  const fs = yield* FileSystem.FileSystem
-  const temp = file + "." + id + ".tmp"
-  yield* fs.makeDirectory(path.dirname(file), { recursive: true })
-  const info = {
-    id,
-    version: OPENCODE_VERSION,
-    url: HttpServer.formatAddress(address),
-    pid: process.pid,
-    password,
-  }
-  const encoded = yield* encodeInfo(info)
-  const current = fs.readFileString(file).pipe(
-    Effect.flatMap(decodeInfo),
-    Effect.orElseSucceed(() => undefined),
-  )
-  const owns = (found: Info | undefined) =>
-    found?.id === info.id &&
-    found.version === info.version &&
-    found.url === info.url &&
-    found.pid === info.pid &&
-    found.password === info.password
-  yield* fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
-  yield* current.pipe(
-    Effect.filterOrFail(owns),
-    Effect.repeat(Schedule.spaced("5 seconds")),
-    Effect.ignore,
-    Effect.andThen(shutdown),
-    Effect.forkScoped,
-  )
-  return current.pipe(
-    Effect.flatMap((found) => (owns(found) ? fs.remove(file) : Effect.void)),
-    Effect.ignore,
-  )
-})

packages/cli/test/service.test.ts

@@ -8,7 +8,6 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { ServiceConfig } from "../src/services/service-config"
-import { ServiceRegistration } from "../src/services/service-registration"
 
 test("managed service ports are stable per installation channel", () => {
   expect(ServiceConfig.defaultPort("latest")).toBe(0xc0de)
@@ -441,37 +440,34 @@ test("port contender recognizes an incumbent registered during the bind race", a
   }
 }, 45_000)
 
-test("service registration replaces a stale owner with the bound address", async () => {
+test("stale dead registration is replaced after binding the selected port", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-stale-"))
+  const port = await availablePort()
   const registration = path.join(root, "state", "opencode", "service-local.json")
+  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
   await fs.mkdir(path.dirname(registration), { recursive: true })
+  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
   await fs.writeFile(
     registration,
-    JSON.stringify({ id: "dead", version: "dead", url: "http://127.0.0.1:4321", pid: 2_147_483_647 }),
+    JSON.stringify({ id: "dead", version: "dead", url: `http://127.0.0.1:${port}`, pid: 2_147_483_647 }),
   )
+  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
+    env: serviceEnv(root),
+    stderr: "pipe",
+    stdout: "ignore",
+  })
   try {
-    const cleanup = await Effect.runPromise(
-      ServiceRegistration.register(
-        { _tag: "TcpAddress", hostname: "127.0.0.1", port: 4321 },
-        "secret",
-        "owner",
-        registration,
-        Effect.never,
-      ).pipe(Effect.scoped, Effect.provide(NodeFileSystem.layer)),
-    )
-    expect(await Bun.file(registration).json()).toEqual({
-      id: "owner",
-      version: OPENCODE_VERSION,
-      url: "http://127.0.0.1:4321",
-      pid: process.pid,
-      password: "secret",
-    })
-    await Effect.runPromise(cleanup.pipe(Effect.provide(NodeFileSystem.layer)))
-    expect(await Bun.file(registration).exists()).toBe(false)
+    const info = await waitForInfo(registration, (value) => value.id !== "dead")
+    expect(new URL(info.url).port).toBe(String(port))
+    expect(info.pid).toBe(owner.pid)
+    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
+    await owner.exited
   } finally {
+    owner.kill("SIGTERM")
+    await owner.exited
     await fs.rm(root, { recursive: true, force: true })
   }
-})
+}, 30_000)
 
 test("a failed service stays registered and owns the selected port until stopped", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-failed-"))

packages/tui/src/routes/session/form.tsx

@@ -523,6 +523,18 @@ export function FormPrompt(props: {
           textarea?.setText("")
         },
       },
+      {
+        id: "prompt.paste",
+        title: "Paste into answer",
+        group: "Form",
+        async run(_input, event) {
+          event?.preventDefault()
+          event?.stopPropagation()
+          const content = await clipboard.read()
+          if (content?.mime !== "text/plain") return
+          textarea?.insertText(content.data)
+        },
+      },
       {
         bind: "escape",
         title: textual() ? "Dismiss form" : "Close answer edit",

packages/tui/test/cli/tui/form.test.tsx

@@ -14,7 +14,7 @@ import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
 import { createApi, createEventStream, createFetch } from "../../fixture/tui-client"
 
-async function mountForm(root: string, width = 80, fields?: FormWithLocation["fields"], height = 20) {
+async function mountForm(root: string, width = 80, fields?: FormWithLocation["fields"], height = 20, pasted?: string) {
   const state = path.join(root, "state")
   await mkdir(state, { recursive: true })
 
@@ -58,7 +58,7 @@ async function mountForm(root: string, width = 80, fields?: FormWithLocation["fi
         }}
         clipboard={{
           async read() {
-            return undefined
+            return pasted ? { data: pasted, mime: "text/plain" } : undefined
           },
           write(text) {
             copied.push(text)
@@ -217,6 +217,34 @@ test("pasting on a custom choice opens its editor without submitting", async ()
   }
 })
 
+test("ctrl-v pastes clipboard text into a custom answer", async () => {
+  await using tmp = await tmpdir()
+  const prompt = await mountForm(
+    tmp.path,
+    80,
+    [
+      {
+        key: "target",
+        type: "string",
+        options: [{ value: "staging", label: "Staging" }],
+        custom: true,
+      },
+    ],
+    20,
+    "production west",
+  )
+  try {
+    prompt.app.mockInput.pressArrow("down")
+    prompt.app.mockInput.pressEnter()
+    await prompt.app.waitFor(() => prompt.app.renderer.currentFocusedEditor !== null)
+
+    prompt.app.mockInput.pressKey("v", { ctrl: true })
+    await prompt.app.waitFor(() => prompt.app.renderer.currentFocusedEditor?.plainText === "production west")
+  } finally {
+    prompt.app.renderer.destroy()
+  }
+})
+
 test("typing a custom multiselect answer selects it before commit", async () => {
   await using tmp = await tmpdir()
   const prompt = await mountForm(tmp.path, 80, [

packages/tui/test/context/session-tabs.test.tsx

@@ -141,15 +141,7 @@ async function renderSessionTabs(
     locations,
     vcsLocations,
     state,
-    emit: (event: OpenCodeEvent) =>
-      new Promise<void>((resolve) => {
-        const off = client.event.listen((delivered) => {
-          if (delivered.details.id !== event.id) return
-          off()
-          resolve()
-        })
-        events.emit({ ...event, location: { directory } })
-      }),
+    emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     focus: () => app.renderer.emit("focus"),
     blur: () => app.renderer.emit("blur"),
     flush: () => storage.flush(),
@@ -266,31 +258,43 @@ test("keeps scroll anchors for open session tabs", async () => {
 })
 
 test("only the foreground TUI mutates unread state", async () => {
+  await using temporary = await tmpdir()
   let foreground: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
   let background: Awaited<ReturnType<typeof renderSessionTabs>> | undefined
 
   try {
-    foreground = await renderSessionTabs("first", { persisted: ["first", "second"] })
-    background = await renderSessionTabs("first", { persisted: ["first", "second"] })
+    foreground = await renderSessionTabs("first", { state: temporary.path, persisted: ["first", "second"] })
+    background = await renderSessionTabs("second", { state: temporary.path })
     foreground.focus()
     background.blur()
+    await wait(() => foreground?.tabs.tabs().length === 2 && background?.tabs.tabs().length === 2, 2_000, "shared tabs")
 
     const firstDone = executionSucceeded("first")
-    await Promise.all([foreground.emit(firstDone), background.emit(firstDone)])
+    foreground.emit(firstDone)
+    background.emit(firstDone)
     await Promise.all([foreground.flush(), background.flush()])
     expect(foreground.tabs.status("first").unread).toBeUndefined()
     expect(background.tabs.status("first").unread).toBeUndefined()
 
     const secondDone = executionSucceeded("second")
-    await Promise.all([foreground.emit(secondDone), background.emit(secondDone)])
-    await Promise.all([foreground.flush(), background.flush()])
-    expect(foreground.tabs.status("second").unread).toBe("activity")
-    expect(background.tabs.status("second").unread).toBeUndefined()
+    foreground.emit(secondDone)
+    background.emit(secondDone)
+    await wait(
+      () =>
+        foreground?.tabs.status("second").unread === "activity" &&
+        background?.tabs.status("second").unread === "activity",
+      10_000,
+      "shared unread activity",
+    )
 
     foreground.tabs.select("second")
-    await foreground.flush()
-    expect(foreground.tabs.status("second").unread).toBeUndefined()
-    expect(background.tabs.status("second").unread).toBeUndefined()
+    await wait(
+      () =>
+        foreground?.tabs.status("second").unread === undefined &&
+        background?.tabs.status("second").unread === undefined,
+      10_000,
+      "shared unread clearing",
+    )
   } finally {
     if (foreground) await foreground.destroy()
     if (background) await background.destroy()