mirror of
https://github.com/anomalyco/opencode.git
synced 2026-07-25 04:35:37 -04:00
Simon Klee
252 lines
9.0 KiB
JavaScript
252 lines
9.0 KiB
JavaScript
import { defineScript } from "opencode-drive"
|
|
import { mkdir } from "node:fs/promises"
|
|
import path from "node:path"
|
|
|
|
export default defineScript({
|
|
launch: "manual",
|
|
setup({ config }) {
|
|
config.autoupdate = false
|
|
},
|
|
async run({ artifacts, llm, server, signal }) {
|
|
await configureServicePort(artifacts)
|
|
await server.launch()
|
|
|
|
const registration = await serviceRegistration(artifacts)
|
|
const root = path.resolve(import.meta.dir, "../../../..")
|
|
const session = `mini-stage2-${process.pid}`
|
|
const snapshots = path.join(artifacts, "mini-stage2")
|
|
await mkdir(snapshots, { recursive: true })
|
|
|
|
llm.queue(
|
|
llm.toolCall({
|
|
index: 0,
|
|
id: "mini-shell",
|
|
name: "shell",
|
|
input: { command: "printf 'drive-mini-tool-output\\n'" },
|
|
}),
|
|
llm.finish("tool-calls"),
|
|
)
|
|
llm.queue(llm.text("drive mini response complete", { delay: 5, chunkSize: 4 }))
|
|
|
|
const abort = () => {
|
|
void tmux(["kill-session", "-t", session], true).catch(() => {})
|
|
}
|
|
signal.addEventListener("abort", abort, { once: true })
|
|
try {
|
|
await tmux([
|
|
"new-session",
|
|
"-d",
|
|
"-s",
|
|
session,
|
|
"-x",
|
|
"140",
|
|
"-y",
|
|
"30",
|
|
"--",
|
|
"env",
|
|
`PWD=${path.join(artifacts, "files")}`,
|
|
`OPENCODE_PASSWORD=${registration.password}`,
|
|
`OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
|
|
`OPENCODE_TEST_HOME=${artifacts}`,
|
|
`XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
|
|
`XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
|
|
`XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
|
|
`XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
|
|
"OPENCODE_DISABLE_AUTOUPDATE=1",
|
|
"OPENCODE_DIRECT_TRACE=1",
|
|
process.execPath,
|
|
"--conditions=browser",
|
|
"--preload=@opentui/solid/preload",
|
|
path.join(root, "packages/cli/src/index.ts"),
|
|
"mini",
|
|
"--server",
|
|
registration.url,
|
|
"--model",
|
|
"simulation/gpt-sim-model",
|
|
])
|
|
await tmux(["set-option", "-t", session, "remain-on-exit", "on"])
|
|
|
|
const first = await waitForPane(session, "OpenCode")
|
|
await Bun.write(path.join(snapshots, "01-first-paint.txt"), first)
|
|
if (first.includes("drive mini response complete")) throw new Error("response rendered before prompt submission")
|
|
|
|
await waitForPane(session, "Simulated Model", 15_000)
|
|
await tmux(["send-keys", "-t", session, "-l", "exercise the mini frontend"])
|
|
await Bun.sleep(100)
|
|
await tmux(["send-keys", "-H", "-t", session, "0d"])
|
|
const completed = await waitForPane(session, "drive mini response complete", 20_000)
|
|
if (!completed.includes("drive-mini-tool-output")) throw new Error("shell tool output was not rendered")
|
|
await Bun.write(path.join(snapshots, "02-tool-and-response.txt"), completed)
|
|
|
|
await Bun.sleep(500)
|
|
const resizeOutput = path.join(snapshots, "03-resize-output.ansi")
|
|
await tmux(["pipe-pane", "-t", session, `cat > ${JSON.stringify(resizeOutput)}`])
|
|
await tmux(["resize-window", "-t", session, "-x", "72", "-y", "22"])
|
|
await waitForFile(
|
|
resizeOutput,
|
|
(value) => value.includes("drive mini response complete") && value.includes("drive-mini-tool-output"),
|
|
)
|
|
await tmux(["pipe-pane", "-t", session])
|
|
const resized = await captureVisiblePane(session)
|
|
if (!resized.includes("drive-mini-tool-output")) throw new Error("resize replay lost shell tool output")
|
|
await Bun.write(path.join(snapshots, "03-resize-replay.txt"), resized)
|
|
|
|
llm.queue(
|
|
llm.toolCall({
|
|
index: 0,
|
|
id: "mini-slow-shell",
|
|
name: "shell",
|
|
input: { command: "sleep 10" },
|
|
}),
|
|
llm.finish("tool-calls"),
|
|
)
|
|
await tmux(["send-keys", "-t", session, "-l", "interrupt this turn"])
|
|
await Bun.sleep(100)
|
|
await tmux(["send-keys", "-H", "-t", session, "0d"])
|
|
await waitForPane(session, "$ sleep 10")
|
|
await tmux(["send-keys", "-t", session, "Escape"])
|
|
const armed = await waitForPane(session, "again to interrupt")
|
|
await Bun.write(path.join(snapshots, "04-interrupt-armed.txt"), armed)
|
|
await tmux(["send-keys", "-t", session, "Escape"])
|
|
const interrupted = await waitForPane(session, "Step interrupted", 10_000)
|
|
await Bun.write(path.join(snapshots, "05-interrupted.txt"), interrupted)
|
|
if (!(await paneAlive(session))) throw new Error("Mini exited while interrupting an active turn")
|
|
|
|
await tmux(["send-keys", "-t", session, "C-c"])
|
|
await waitForPane(session, "Press ctrl+c again to exit")
|
|
await tmux(["send-keys", "-t", session, "C-c"])
|
|
await waitForDeadPane(session)
|
|
const status = await paneDeadStatus(session)
|
|
if (status !== 0) throw new Error(`Mini exited with status ${status}`)
|
|
const exited = await capturePane(session)
|
|
if (!exited.includes("Continue") || !exited.includes("opencode mini -s"))
|
|
throw new Error("Mini exit splash was not rendered before teardown")
|
|
await Bun.write(path.join(snapshots, "06-exit-teardown.txt"), exited)
|
|
} finally {
|
|
signal.removeEventListener("abort", abort)
|
|
await tmux(["kill-session", "-t", session], true)
|
|
}
|
|
},
|
|
})
|
|
|
|
/** @param {string[]} args */
|
|
async function tmux(args, allowFailure = false) {
|
|
const child = Bun.spawn(["tmux", ...args], { stdout: "pipe", stderr: "pipe" })
|
|
let timedOut = false
|
|
const timeout = setTimeout(() => {
|
|
timedOut = true
|
|
child.kill("SIGKILL")
|
|
}, 5_000)
|
|
const [status, stdout, stderr] = await Promise.all([
|
|
child.exited,
|
|
new Response(child.stdout).text(),
|
|
new Response(child.stderr).text(),
|
|
])
|
|
clearTimeout(timeout)
|
|
if (timedOut) throw new Error(`tmux ${args[0]} timed out`)
|
|
if (status !== 0 && !allowFailure) throw new Error(`tmux ${args[0]} failed: ${stderr || stdout}`)
|
|
return stdout
|
|
}
|
|
|
|
/** @param {string} session */
|
|
function capturePane(session) {
|
|
return tmux(["capture-pane", "-p", "-t", session, "-S", "-"])
|
|
}
|
|
|
|
/** @param {string} session */
|
|
function captureVisiblePane(session) {
|
|
return tmux(["capture-pane", "-p", "-t", session])
|
|
}
|
|
|
|
/** @param {string} session */
|
|
async function paneAlive(session) {
|
|
return (await tmux(["display-message", "-p", "-t", session, "#{pane_dead}"], true)).trim() === "0"
|
|
}
|
|
|
|
/** @param {string} session */
|
|
async function paneDeadStatus(session) {
|
|
return Number((await tmux(["display-message", "-p", "-t", session, "#{pane_dead_status}"])).trim())
|
|
}
|
|
|
|
/**
|
|
* @param {string} session
|
|
* @param {string} text
|
|
* @param {number} [timeout]
|
|
* @param {(() => Promise<void>) | undefined} [trigger]
|
|
*/
|
|
async function waitForPane(session, text, timeout = 5_000, trigger) {
|
|
const deadline = Date.now() + timeout
|
|
let last = ""
|
|
while (Date.now() < deadline) {
|
|
await trigger?.()
|
|
last = await capturePane(session)
|
|
if (last.includes(text)) return last
|
|
if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
|
|
await Bun.sleep(50)
|
|
}
|
|
throw new Error(`Timed out waiting for ${JSON.stringify(text)}:\n${last}`)
|
|
}
|
|
|
|
/** @param {string} session */
|
|
async function waitForDeadPane(session) {
|
|
for (let attempt = 0; attempt < 100; attempt++) {
|
|
if (!(await paneAlive(session))) return
|
|
await Bun.sleep(50)
|
|
}
|
|
throw new Error("Mini did not tear down after the exit sequence")
|
|
}
|
|
|
|
/**
|
|
* @param {string} file
|
|
* @param {(value: string) => boolean} accept
|
|
*/
|
|
async function waitForFile(file, accept) {
|
|
let value = ""
|
|
for (let attempt = 0; attempt < 100; attempt++) {
|
|
value = await Bun.file(file)
|
|
.text()
|
|
.catch(() => "")
|
|
if (accept(value)) return value
|
|
await Bun.sleep(50)
|
|
}
|
|
throw new Error("resize did not replay committed transcript output")
|
|
}
|
|
|
|
/** @param {string} artifacts */
|
|
async function configureServicePort(artifacts) {
|
|
const probe = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response() })
|
|
const port = probe.port
|
|
await probe.stop(true)
|
|
if (!port) throw new Error("Failed to allocate a Drive service port")
|
|
const file = path.join(artifacts, "files/.opencode/service-local.json")
|
|
await mkdir(path.dirname(file), { recursive: true })
|
|
await Bun.write(file, JSON.stringify({ port }))
|
|
}
|
|
|
|
/** @param {string} artifacts */
|
|
async function serviceRegistration(artifacts) {
|
|
const directory = path.join(artifacts, "home/.local/state/opencode")
|
|
for (let attempt = 0; attempt < 200; attempt++) {
|
|
for (const name of ["service-local.json", "service.json"]) {
|
|
const value = await Bun.file(path.join(directory, name))
|
|
.json()
|
|
.catch(() => undefined)
|
|
if (isRegistration(value)) return value
|
|
}
|
|
await Bun.sleep(50)
|
|
}
|
|
throw new Error("Drive service registration was not written")
|
|
}
|
|
|
|
/** @param {unknown} value */
|
|
function isRegistration(value) {
|
|
return (
|
|
typeof value === "object" &&
|
|
value !== null &&
|
|
"url" in value &&
|
|
typeof value.url === "string" &&
|
|
"password" in value &&
|
|
typeof value.password === "string"
|
|
)
|
|
}
|