mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-17 05:26:47 +03:00
fix(session-ui): stop refetching missing shell output (#47926)
This commit is contained in:
committed by
GitHub
Unverified
parent
ea2c0184ce
commit
a3d5923aca
@@ -0,0 +1,128 @@
|
||||
import { describe, expect, test, vi } from "bun:test"
|
||||
import type { ShellOutputInput, ShellOutputOutput } from "@opencode/client/promise"
|
||||
import { followShellOutput, SHELL_OUTPUT_TAIL_BYTES } from "./shell-output"
|
||||
|
||||
const location = { directory: "/repo", project: { id: "project", directory: "/repo", canonical: "/repo" } }
|
||||
|
||||
// Serves the current text from the requested cursor, at most one page per request.
|
||||
function server(text: () => string, page = Infinity) {
|
||||
const cursors: number[] = []
|
||||
return {
|
||||
cursors,
|
||||
load: (input: ShellOutputInput): Promise<ShellOutputOutput> => {
|
||||
const cursor = input.cursor ?? 0
|
||||
cursors.push(cursor)
|
||||
const full = text()
|
||||
const output = full.slice(cursor, cursor + page)
|
||||
return Promise.resolve({
|
||||
location,
|
||||
data: { output, cursor: cursor + output.length, size: full.length, truncated: false },
|
||||
})
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// Reads settle within a few microtasks; timers are faked so this never waits on the clock.
|
||||
async function flush() {
|
||||
for (let i = 0; i < 20; i++) await Promise.resolve()
|
||||
}
|
||||
|
||||
describe("followShellOutput", () => {
|
||||
test("stops polling a missing shell and never requests it again", async () => {
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
const cursors: number[] = []
|
||||
const load = (input: ShellOutputInput): Promise<ShellOutputOutput> => {
|
||||
cursors.push(input.cursor ?? 0)
|
||||
return Promise.reject({ _tag: "ShellNotFoundError", id: input.id, message: "Shell command not found" })
|
||||
}
|
||||
const follow = () =>
|
||||
followShellOutput({ id: "shell_missing", directory: "/repo", running: true, load, onOutput() {} })
|
||||
|
||||
const stop = follow()
|
||||
await flush()
|
||||
expect(cursors).toEqual([0])
|
||||
|
||||
vi.advanceTimersByTime(10_000)
|
||||
await flush()
|
||||
expect(cursors).toEqual([0])
|
||||
|
||||
stop()
|
||||
const remounted = follow()
|
||||
await flush()
|
||||
vi.advanceTimersByTime(10_000)
|
||||
remounted()
|
||||
expect(cursors).toEqual([0])
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
})
|
||||
|
||||
test("polls a running shell once per second and resumes from the cached cursor after a remount", async () => {
|
||||
vi.useFakeTimers()
|
||||
try {
|
||||
let text = "hello\n"
|
||||
const shell = server(() => text)
|
||||
const outputs: string[] = []
|
||||
const follow = (running: boolean) =>
|
||||
followShellOutput({
|
||||
id: "shell_live",
|
||||
directory: "/repo",
|
||||
running,
|
||||
load: shell.load,
|
||||
onOutput: (output) => outputs.push(output),
|
||||
})
|
||||
|
||||
const first = follow(true)
|
||||
await flush()
|
||||
expect(outputs.at(-1)).toBe("hello\n")
|
||||
|
||||
text += "world\n"
|
||||
vi.advanceTimersByTime(1_000)
|
||||
await flush()
|
||||
expect(shell.cursors).toEqual([0, 6])
|
||||
expect(outputs.at(-1)).toBe("hello\nworld\n")
|
||||
|
||||
first()
|
||||
text += "done\n"
|
||||
const second = follow(true)
|
||||
await flush()
|
||||
expect(shell.cursors).toEqual([0, 6, 12])
|
||||
expect(outputs.at(-1)).toBe("hello\nworld\ndone\n")
|
||||
|
||||
second()
|
||||
const exited = follow(false)
|
||||
await flush()
|
||||
exited()
|
||||
expect(shell.cursors).toEqual([0, 6, 12, 17])
|
||||
|
||||
outputs.length = 0
|
||||
follow(false)()
|
||||
await flush()
|
||||
expect(shell.cursors).toEqual([0, 6, 12, 17])
|
||||
expect(outputs).toEqual(["hello\nworld\ndone\n"])
|
||||
|
||||
// The running-shell inventory can arrive late; a complete shell believed to be live is re-read from its cursor.
|
||||
follow(true)()
|
||||
expect(shell.cursors).toEqual([0, 6, 12, 17, 17])
|
||||
} finally {
|
||||
vi.useRealTimers()
|
||||
}
|
||||
})
|
||||
|
||||
test("keeps only the most recent tail of a large output", async () => {
|
||||
const shell = server(() => "a".repeat(SHELL_OUTPUT_TAIL_BYTES) + "tail", SHELL_OUTPUT_TAIL_BYTES)
|
||||
const outputs: string[] = []
|
||||
followShellOutput({
|
||||
id: "shell_large",
|
||||
directory: "/repo",
|
||||
running: false,
|
||||
load: shell.load,
|
||||
onOutput: (output) => outputs.push(output),
|
||||
})
|
||||
await flush()
|
||||
expect(shell.cursors).toEqual([0, SHELL_OUTPUT_TAIL_BYTES])
|
||||
expect(outputs.at(-1)?.length).toBe(SHELL_OUTPUT_TAIL_BYTES)
|
||||
expect(outputs.at(-1)?.endsWith("a".repeat(8) + "tail")).toBe(true)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,74 @@
|
||||
import { isShellNotFoundError, type ShellOutputInput, type ShellOutputOutput } from "@opencode/client/promise"
|
||||
|
||||
// Same page size as the TUI shell output viewer; only this much recent output is retained and rendered.
|
||||
export const SHELL_OUTPUT_TAIL_BYTES = 64 * 1024
|
||||
const PROGRESS_LIMIT = 32
|
||||
|
||||
type Progress = { cursor: number; output: string; state: "partial" | "complete" | "missing" }
|
||||
|
||||
// Virtualized timelines remount shell tools frequently. Progress is remembered per shell so a
|
||||
// remount resumes from its cursor instead of re-reading from zero, and so a shell the server no
|
||||
// longer knows is never requested again.
|
||||
const progress = new Map<string, Progress>()
|
||||
|
||||
function remember(id: string, entry: Progress) {
|
||||
progress.delete(id)
|
||||
progress.set(id, entry)
|
||||
if (progress.size <= PROGRESS_LIMIT) return
|
||||
const oldest = progress.keys().next().value
|
||||
if (oldest !== undefined) progress.delete(oldest)
|
||||
}
|
||||
|
||||
export function followShellOutput(input: {
|
||||
id: string
|
||||
directory: string
|
||||
running: boolean
|
||||
load: (input: ShellOutputInput) => Promise<ShellOutputOutput>
|
||||
onOutput: (output: string) => void
|
||||
}) {
|
||||
const cached = progress.get(input.id)
|
||||
if (cached) {
|
||||
remember(input.id, cached)
|
||||
input.onOutput(cached.output)
|
||||
}
|
||||
// A missing shell never comes back. A complete one is only re-read while the shell is believed to be
|
||||
// running, because the running-shell inventory can arrive after history has already rendered.
|
||||
if (cached?.state === "missing" || (cached?.state === "complete" && !input.running)) return () => {}
|
||||
let cursor = cached?.cursor ?? 0
|
||||
let text = cached?.output ?? ""
|
||||
let loading = false
|
||||
let disposed = false
|
||||
const read = async () => {
|
||||
if (loading) return
|
||||
loading = true
|
||||
while (true) {
|
||||
const page = await input.load({ id: input.id, location: { directory: input.directory }, cursor }).then(
|
||||
(response) => response.data,
|
||||
(cause: unknown) => (isShellNotFoundError(cause) ? "missing" : undefined),
|
||||
)
|
||||
if (disposed) break
|
||||
if (page === "missing") {
|
||||
// The server drops exited shells past its retention limit; stop asking for this one.
|
||||
remember(input.id, { cursor, output: text, state: "missing" })
|
||||
clearInterval(interval)
|
||||
break
|
||||
}
|
||||
if (!page) break
|
||||
const advanced = page.cursor > cursor
|
||||
cursor = Math.max(cursor, page.cursor)
|
||||
text = (text + page.output).slice(-SHELL_OUTPUT_TAIL_BYTES)
|
||||
const complete = !input.running && cursor >= page.size
|
||||
remember(input.id, { cursor, output: text, state: complete ? "complete" : "partial" })
|
||||
input.onOutput(text)
|
||||
if (input.running || complete || !advanced) break
|
||||
}
|
||||
loading = false
|
||||
}
|
||||
void read()
|
||||
// Refresh the final snapshot on exit, but poll only while the shell is live.
|
||||
const interval = input.running ? setInterval(() => void read(), 1_000) : undefined
|
||||
return () => {
|
||||
disposed = true
|
||||
clearInterval(interval)
|
||||
}
|
||||
}
|
||||
@@ -51,6 +51,7 @@ import {
|
||||
executeToolFailed,
|
||||
} from "../message/current-tool-state"
|
||||
import { AssistantReasoningContent, writeClipboard } from "../message/message-content"
|
||||
import { followShellOutput } from "./shell-output"
|
||||
|
||||
function ShellSubmessage(props: { text: string; animate?: boolean }) {
|
||||
let widthRef: HTMLSpanElement | undefined
|
||||
@@ -1629,33 +1630,9 @@ ToolRegistry.register({
|
||||
createEffect(() => {
|
||||
if (saved() !== undefined) return
|
||||
const id = props.metadata.shellID
|
||||
const shellOutput = data.shellOutput
|
||||
if (typeof id !== "string" || !shellOutput) return
|
||||
const directory = data.directory
|
||||
const running = pending()
|
||||
let cursor = 0
|
||||
let loading = false
|
||||
let disposed = false
|
||||
const load = async () => {
|
||||
if (loading) return
|
||||
loading = true
|
||||
do {
|
||||
const response = await shellOutput({ id, location: { directory }, cursor }).catch(() => undefined)
|
||||
if (disposed || !response) break
|
||||
setStreamed((output) => (cursor === 0 ? response.data.output : output + response.data.output))
|
||||
if (response.data.cursor <= cursor) break
|
||||
cursor = response.data.cursor
|
||||
if (running || cursor >= response.data.size) break
|
||||
} while (!disposed)
|
||||
loading = false
|
||||
}
|
||||
void load()
|
||||
// Refresh the final snapshot on exit, but poll only while the shell is live.
|
||||
const interval = running ? setInterval(() => void load(), 1_000) : undefined
|
||||
onCleanup(() => {
|
||||
disposed = true
|
||||
clearInterval(interval)
|
||||
})
|
||||
const load = data.shellOutput
|
||||
if (typeof id !== "string" || !load) return
|
||||
onCleanup(followShellOutput({ id, directory: data.directory, running: pending(), load, onOutput: setStreamed }))
|
||||
})
|
||||
const command = () => {
|
||||
if (typeof props.input.command === "string") return props.input.command
|
||||
|
||||
Reference in New Issue
Block a user