fix(desktop): ignore packaged renderer override

packages/desktop/src/main/renderer-url.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import { resolveRendererDevUrl } from "./renderer-url"
+
+describe("renderer development URL", () => {
+  test("allows a valid URL in development", () => {
+    expect(resolveRendererDevUrl(false, "http://localhost:5173")?.origin).toBe("http://localhost:5173")
+  })
+
+  test("ignores the override in packaged applications", () => {
+    expect(resolveRendererDevUrl(true, "https://example.com")).toBeUndefined()
+  })
+
+  test("ignores invalid URLs", () => {
+    expect(resolveRendererDevUrl(false, "not a url")).toBeUndefined()
+  })
+})

packages/desktop/src/main/renderer-url.ts

@@ -0,0 +1,4 @@
+export function resolveRendererDevUrl(packaged: boolean, value?: string) {
+  if (packaged || !value || !URL.canParse(value)) return undefined
+  return new URL(value)
+}

packages/desktop/src/main/windows.ts

@@ -15,6 +15,7 @@ import { createUnresponsiveSampler } from "./unresponsive"
 import { nativeT } from "./native-translations"
 import { createWindowRegistry } from "./window-registry"
 import { safeWindowURL } from "./window-state"
+import { resolveRendererDevUrl } from "./renderer-url"
 import { resolveExternalURL, resolveLocalFilePath } from "./external-url"
 
 const root = dirname(fileURLToPath(import.meta.url))
@@ -332,7 +333,7 @@ export function registerRendererProtocol() {
 }
 
 function loadWindow(win: BrowserWindow, html: string) {
-  const devUrl = process.env.ELECTRON_RENDERER_URL
+  const devUrl = resolveRendererDevUrl(app.isPackaged, process.env.ELECTRON_RENDERER_URL)
   if (devUrl) {
     const url = new URL(html, devUrl)
     void win.loadURL(url.toString())
@@ -510,9 +511,8 @@ function isRendererUrl(value?: string, html = false) {
   const url = new URL(value)
   if (html && !url.pathname.endsWith(".html")) return false
   if (url.protocol === `${rendererProtocol}:` && url.host === rendererHost) return true
-  const devUrl = process.env.ELECTRON_RENDERER_URL
-  if (!devUrl || !URL.canParse(devUrl)) return false
-  return url.origin === new URL(devUrl).origin
+  const devUrl = resolveRendererDevUrl(app.isPackaged, process.env.ELECTRON_RENDERER_URL)
+  return devUrl ? url.origin === devUrl.origin : false
 }
 
 function wireZoom(win: BrowserWindow) {

packages/simulation/src/frontend/actions.ts

@@ -115,10 +115,9 @@ export function elements(renderer: CliRenderer): Element[] {
 }
 
 export function state(harness: Harness) {
-  const renderable = harness.renderer.currentFocusedRenderable?.num
   return {
     focused: {
-      ...(renderable === undefined ? {} : { renderable }),
+      renderable: harness.renderer.currentFocusedRenderable?.num,
       editor: Boolean(harness.renderer.currentFocusedEditor),
     },
     elements: elements(harness.renderer),

packages/simulation/test/actions.test.ts

@@ -14,18 +14,6 @@ test("matches literal screen text", () => {
   expect(matches(harness, "opencode")).toBe(false)
 })
 
-test("omits an absent focused renderable from state", () => {
-  const harness = {
-    renderer: {
-      root: { getChildren: () => [] },
-      currentFocusedRenderable: undefined,
-      currentFocusedEditor: undefined,
-    },
-  } as unknown as Harness
-
-  expect(state(harness)).toEqual({ focused: { editor: false }, elements: [] })
-})
-
 test("normalizes named keys for OpenTUI", async () => {
   const pressed: Array<readonly [string, object | undefined]> = []
   const harness = {

packages/tui/src/component/session-tabs.tsx

@@ -21,7 +21,6 @@ import {
   moveSessionTab,
   NEW_SESSION_TAB_TITLE,
   sessionTabComplete,
-  sessionTabDetail,
   sessionTabShortcutLabel,
   seedSessionTabMotion,
   sessionTabOverflowWidth,
@@ -409,20 +408,10 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const titleFades = createMemo(() => marqueeOverflows(title(), titleWidth()) && titleWidth() > FADE_WIDTH)
               const detail = createMemo(() => {
                 const fixture = tabs.detail?.(tab.sessionID)
-                if (fixture !== undefined) return fixture
+                if (fixture !== undefined) return Locale.takeWidth(fixture, titleWidth())
                 const value = session()
-                const currentProject = project()
-                const projectLabel = projectName(currentProject, value?.location.directory) ?? ""
-                const vcs = value ? data.location.vcs.info(value.location) : undefined
-                const location = value ? data.location.info(value.location) : undefined
-                const worktree = !!location && location.project.directory !== location.project.canonical
-                return sessionTabDetail(projectLabel, vcs?.branch.current, vcs?.branch.default, worktree)
+                return Locale.takeWidth(projectName(project(), value?.location.directory) ?? "", titleWidth())
               })
-              const visibleDetail = createMemo(() => Locale.takeWidth(detail(), titleWidth()))
-              const visibleDetailParts = createMemo(() => Locale.graphemes(visibleDetail()))
-              const detailFades = createMemo(
-                () => marqueeOverflows(detail(), titleWidth()) && titleWidth() > FADE_WIDTH,
-              )
               const background = createMemo(() => {
                 if (selected()) return theme.background.action.primary.selected
                 if (hovered() === tab.sessionID || dragging() === tab.sessionID)
@@ -464,10 +453,6 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const detailFlashColor = createMemo(() => tint(pulseBackground(), theme.text.default, 0.42))
               const detailGlowColor = createMemo(() => tint(pulseBackground(), glowHue(), 0.25))
               const detailColor = createMemo(() => tint(theme.text.subdued, pulseBackground(), 0.35))
-              const detailTextColor = (index: number) =>
-                detailFades()
-                  ? fadeTitleColor(detailColor(), pulseBackground(), index, visibleDetailParts().length, 0)
-                  : detailColor()
               const glows = () => status().glows
               const previous = createMemo(() => items()[index() - 1])
               const previousStatus = createMemo(() => {
@@ -685,11 +670,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                     />
                     <box zIndex={1} width="100%" flexDirection="row" paddingLeft={numberWidth() + 1} paddingRight={2}>
                       <text fg={detailColor()} wrapMode="none" selectable={false}>
-                        <Show when={detailFades()} fallback={visibleDetail()}>
-                          <For each={visibleDetailParts()}>
-                            {(character, index) => <span style={{ fg: detailTextColor(index()) }}>{character}</span>}
-                          </For>
-                        </Show>
+                        {detail()}
                       </text>
                     </box>
                   </box>

packages/tui/src/context/data.tsx

@@ -94,7 +94,7 @@ type Store = {
   location: Record<string, LocationData>
 }
 
-export function locationKey(location: LocationRef) {
+function locationKey(location: LocationRef) {
   return JSON.stringify([location.directory, location.workspaceID])
 }
 
@@ -1214,9 +1214,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         default() {
           return defaultLocation()
         },
-        syncInfo(ref?: LocationRef) {
+        async sync(ref?: LocationRef) {
           const current = ref ?? defaultLocation()
-          return sync.run(`location:${locationKey(current)}`, async () => {
+          await sync.run(`location:${locationKey(current)}`, async () => {
             const location = await client.api.location.get({ location: locationQuery(current) })
             const key = locationKey(location)
             if (!store.location[key]) setStore("location", key, {})
@@ -1225,9 +1225,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               setDefaultLocation({ directory: location.directory, workspaceID: location.workspaceID })
             }
           })
-        },
-        async sync(ref?: LocationRef) {
-          await result.location.syncInfo(ref)
           const location = ref ?? defaultLocation()
           await Promise.all([
             result.location.vcs.sync(location),

packages/tui/src/context/session-tabs-model.ts

@@ -13,16 +13,6 @@ export function sessionTabShortcutLabel(index: number) {
   return "·"
 }
 
-export function sessionTabDetail(
-  project: string,
-  current: string | undefined,
-  defaultBranch: string | undefined,
-  worktree: boolean,
-) {
-  const branch = worktree && current !== defaultBranch ? current : undefined
-  return branch && project ? `${project} ⎇ ${branch}` : (branch ?? project)
-}
-
 export type SessionTabHistory = {
   entries: readonly string[]
   index: number

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

@@ -2,7 +2,7 @@ import { createEffect, createMemo, createSignal, onCleanup } from "solid-js"
 import { isDeepEqual } from "remeda"
 import { createSimpleContext } from "./helper"
 import { useClient } from "./client"
-import { locationKey, useData } from "./data"
+import { useData } from "./data"
 import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 import { useEvent } from "./event"
 import { useRoute } from "./route"
@@ -159,9 +159,9 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })
     })
 
-    // Load lightweight session and location metadata concurrently so persisted tabs can resolve
-    // their project and branch labels. Delay the heavier per-tab data so the visible session keeps
-    // the first connection slots and switches still render from a warm cache.
+    // Load lightweight session metadata concurrently so persisted tabs can resolve their project
+    // labels immediately. Delay the heavier per-tab data so the visible session keeps the first
+    // connection slots and switches still render from a warm cache.
     const openTabSessions = createMemo(() =>
       state()
         .tabs.map((tab) => tab.sessionID)
@@ -171,25 +171,10 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     createEffect(() => {
       if (!enabled()) return
       if (client.connection.status() !== "connected") return
-      const signature = openTabSessions()
-      if (signature === "") return
-      const sessionIDs = signature.split("\n")
+      const sessionIDs = openTabSessions()
+      if (sessionIDs === "") return
+      void Promise.allSettled(sessionIDs.split("\n").map((sessionID) => data.session.sync(sessionID)))
       let stale = false
-      void (async () => {
-        await Promise.allSettled(sessionIDs.map((sessionID) => data.session.sync(sessionID)))
-        if (stale) return
-        const locations = new Map(
-          sessionIDs
-            .map((sessionID) => data.session.get(sessionID)?.location)
-            .filter((location) => location !== undefined)
-            .map((location) => [locationKey(location), location]),
-        )
-        await Promise.allSettled(
-          Array.from(locations.values(), (location) =>
-            Promise.all([data.location.syncInfo(location), data.location.vcs.sync(location)]),
-          ),
-        )
-      })()
       const timer = setTimeout(async () => {
         const sessions = state()
           .tabs.map((tab) => tab.sessionID)

packages/tui/src/routes/session/composer/shell-tab.tsx

@@ -23,19 +23,6 @@ export function ShellTab(props: { sessionID: string }) {
 
   const selectedEntry = createMemo(() => entries()[store.selected])
 
-  const keymap = Keymap.use()
-  createEffect(() => {
-    if (!composer.active("shell")) return
-    const cleanup = keymap.intercept("key", ({ event, consume }) => {
-      if (event.name !== "d" || !event.ctrl) return
-      if (!shortcuts.list("composer.shell.kill").includes("ctrl+d")) return
-      if (!selectedEntry()) return
-      consume()
-      keymap.dispatch("composer.shell.kill")
-    })
-    onCleanup(cleanup)
-  })
-
   createEffect(() => {
     if (store.selected >= entries().length) setStore("selected", Math.max(0, entries().length - 1))
   })

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

@@ -2799,10 +2799,6 @@ function Shell(props: ToolProps) {
   const isRunning = createMemo(() => props.part.state.status === "running" || backgroundRunning())
   const command = createMemo(() => stringValue(props.input.command))
   const workdir = createMemo(() => pathFormatter.format(stringValue(props.input.workdir)))
-  const failedExit = createMemo(() => {
-    const exit = finiteNumber(props.metadata.exit)
-    return exit !== undefined && exit !== 0 ? exit : undefined
-  })
   const [expanded, setExpanded] = createSignal(false)
   const [backgroundOutput, setBackgroundOutput] = createSignal("")
   const [outputTruncated, setOutputTruncated] = createSignal(false)
@@ -2929,9 +2925,6 @@ function Shell(props: ToolProps) {
             <text fg={theme.text.subdued}>{limitedOutput()}</text>
           </Show>
         </Show>
-        <Show when={failedExit()}>
-          {(exit) => <text fg={theme.text.feedback.error.default}>× exited with code {exit()}</text>}
-        </Show>
         <Show when={background()}>
           <StatusBadge>Background</StatusBadge>
         </Show>

packages/tui/test/cli/tui/composer-keymap.test.tsx

@@ -23,11 +23,7 @@ const sessions = {
 
 const shells = [shell("sh-a", "bun test"), shell("sh-b", "bun dev")]
 
-async function renderComposer(
-  defaultTab: "subagents" | "shell",
-  keybinds: Partial<TuiKeybind.Keybinds>,
-  focusedTextarea = false,
-) {
+async function renderComposer(defaultTab: "subagents" | "shell", keybinds: Partial<TuiKeybind.Keybinds>) {
   const events = createEventStream()
   const interrupted: string[] = []
   const removed: string[] = []
@@ -73,21 +69,7 @@ async function renderComposer(
         .then(() => wait(() => data.session.status("child-a") === "running"))
         .then(() => ready.resolve(), ready.reject)
     })
-    return (
-      <>
-        {focusedTextarea && <textarea focused={true} initialValue="draft" />}
-        <Composer sessionID="parent" open={true} defaultTab={defaultTab} onClose={() => closed++} />
-      </>
-    )
-  }
-
-  function AppExit() {
-    Keymap.createLayer(() => ({
-      mode: "global",
-      commands: [{ id: "app.exit", title: "Exit", group: "System", run: () => {} }],
-    }))
-    Keymap.createLayer(() => ({ bindings: ["app.exit"] }))
-    return null
+    return <Composer sessionID="parent" open={true} defaultTab={defaultTab} onClose={() => closed++} />
   }
 
   const app = await testRender(
@@ -95,7 +77,6 @@ async function renderComposer(
       <TestTuiContexts directory={directory}>
         <ConfigProvider config={createTuiResolvedConfig({ keybinds })}>
           <Keymap.Provider>
-            <AppExit />
             <ClientProvider api={createApi(calls.fetch)}>
               <DataProvider>
                 <LocationProvider>
@@ -173,18 +154,6 @@ test("disabled shell bindings have no component fallbacks", async () => {
   }
 })
 
-test("shell kill binding overrides app exit", async () => {
-  const composer = await renderComposer("shell", {}, true)
-  try {
-    expect(composer.app.captureCharFrame()).toContain("bun test")
-    composer.app.mockInput.pressKey("d", { ctrl: true })
-    await wait(() => composer.removed.length === 1)
-    expect(composer.removed).toEqual(["sh-a"])
-  } finally {
-    composer.app.renderer.destroy()
-  }
-})
-
 function session(id: string, title: string, parentID?: string) {
   return {
     id,

packages/tui/test/context/session-tabs-model.test.ts

@@ -11,20 +11,11 @@ import {
   reopenSessionTab,
   seedSessionTabMotion,
   sessionTabComplete,
-  sessionTabDetail,
   sessionTabOverflowWidth,
   sessionTabShortcutLabel,
 } from "../../src/context/session-tabs-model"
 
 describe("session tabs", () => {
-  test("appends the branch to the project detail", () => {
-    expect(sessionTabDetail("opencode", "feature/sidebar", "main", true)).toBe("opencode ⎇ feature/sidebar")
-    expect(sessionTabDetail("opencode", "feature/sidebar", undefined, true)).toBe("opencode ⎇ feature/sidebar")
-    expect(sessionTabDetail("opencode", "feature/sidebar", "main", false)).toBe("opencode")
-    expect(sessionTabDetail("opencode", "main", "main", true)).toBe("opencode")
-    expect(sessionTabDetail("opencode", undefined, "main", true)).toBe("opencode")
-  })
-
   test("labels direct shortcut tabs and marks unbound tabs with a dot", () => {
     expect(Array.from({ length: 12 }, (_, index) => sessionTabShortcutLabel(index))).toEqual([
       "1",

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

@@ -28,14 +28,7 @@ async function wait(fn: () => boolean | Promise<boolean>, timeout = 2_000) {
 
 async function renderSessionTabs(
   initialSessionID: string,
-  options?: {
-    state?: string
-    title?: string
-    home?: boolean
-    persisted?: string[]
-    sessionGate?: Promise<void>
-    sessionDirectories?: Record<string, string>
-  },
+  options?: { state?: string; title?: string; home?: boolean; persisted?: string[]; sessionGate?: Promise<void> },
 ) {
   const temporary = options?.state ? undefined : await tmpdir()
   const state = options?.state ?? temporary!.path
@@ -52,25 +45,7 @@ async function renderSessionTabs(
   }
   const events = createEventStream()
   const sessions: string[] = []
-  const locations: string[] = []
-  const vcsLocations: string[] = []
   const calls = createFetch(async (url) => {
-    if (url.pathname === "/api/location") {
-      const requested = url.searchParams.get("location[directory]") ?? directory
-      locations.push(requested)
-      return json({
-        directory: requested,
-        project: { id: "project", directory: requested, canonical: directory },
-      })
-    }
-    if (url.pathname === "/api/vcs") {
-      const requested = url.searchParams.get("location[directory]") ?? directory
-      vcsLocations.push(requested)
-      return json({
-        location: { directory: requested },
-        data: { branch: { current: "main", default: "main" } },
-      })
-    }
     const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
     if (!sessionID) return undefined
     sessions.push(sessionID)
@@ -80,7 +55,7 @@ async function renderSessionTabs(
         id: sessionID,
         title: sessionID === initialSessionID ? options?.title : undefined,
         projectID: "project",
-        location: { directory: options?.sessionDirectories?.[sessionID] ?? directory },
+        location: { directory },
         cost: 0,
         tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
         time: { created: 0, updated: 0 },
@@ -132,8 +107,6 @@ async function renderSessionTabs(
     route,
     data,
     sessions,
-    locations,
-    vcsLocations,
     state,
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     async destroy() {
@@ -164,22 +137,6 @@ test("loads persisted tab metadata concurrently on connect", async () => {
   }
 })
 
-test("loads VCS metadata for each persisted tab location", async () => {
-  const other = `${directory}/other-worktree`
-  const setup = await renderSessionTabs("first", {
-    home: true,
-    persisted: ["first", "second"],
-    sessionDirectories: { second: other },
-  })
-
-  try {
-    await wait(() => setup.locations.includes(other))
-    await wait(() => setup.vcsLocations.includes(other))
-  } finally {
-    await setup.destroy()
-  }
-})
-
 test("stores session tabs for the current working directory by default", async () => {
   const setup = await renderSessionTabs("first")