365 lines
12 KiB
JavaScript
365 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { execFileSync, spawn } from 'node:child_process'
|
|
import {
|
|
chmodSync,
|
|
existsSync,
|
|
mkdtempSync,
|
|
mkdirSync,
|
|
readFileSync,
|
|
rmSync,
|
|
writeFileSync
|
|
} from 'node:fs'
|
|
import net from 'node:net'
|
|
import os from 'node:os'
|
|
import path from 'node:path'
|
|
import { createInterface } from 'node:readline'
|
|
|
|
const repoRoot = path.resolve(import.meta.dirname, '..', '..')
|
|
const clientScript = path.join(import.meta.dirname, 'remote-agent-session-repro-client.mjs')
|
|
const fixtureScript = path.join(import.meta.dirname, 'remote-agent-session-repro-fixture.mjs')
|
|
// Why: macOS limits Unix-domain socket paths to 104 bytes; the server profile
|
|
// creates nested daemon/runtime sockets below this disposable directory.
|
|
const scratch = mkdtempSync(path.join(os.tmpdir(), 'oa-'))
|
|
const profilePath = path.join(scratch, 'profile')
|
|
const projectPath = path.join(scratch, 'repo')
|
|
const binPath = path.join(scratch, 'bin')
|
|
const spawnMarkerPath = path.join(scratch, 'agent-spawns.txt')
|
|
const exitTriggerPath = path.join(scratch, 'exit-agent')
|
|
const childProcesses = new Set()
|
|
let server = null
|
|
|
|
try {
|
|
mkdirSync(profilePath, { recursive: true })
|
|
mkdirSync(projectPath, { recursive: true })
|
|
mkdirSync(binPath, { recursive: true })
|
|
execFileSync('git', ['init', projectPath], { stdio: 'ignore' })
|
|
execFileSync(
|
|
'git',
|
|
[
|
|
'-C',
|
|
projectPath,
|
|
'-c',
|
|
'user.name=Orca Repro',
|
|
'-c',
|
|
'user.email=orca-repro@example.invalid',
|
|
'commit',
|
|
'--allow-empty',
|
|
'-m',
|
|
'Initial repro fixture'
|
|
],
|
|
{ stdio: 'ignore' }
|
|
)
|
|
const fixtureAgentPath = installFixtureAgent(binPath)
|
|
writeFileSync(
|
|
path.join(profilePath, 'orca-data.json'),
|
|
JSON.stringify({
|
|
settings: { agentCmdOverrides: { codex: quoteFixtureAgentCommand(fixtureAgentPath) } }
|
|
})
|
|
)
|
|
|
|
const port = await reservePort()
|
|
const firstReady = await startServer(port)
|
|
const pairingCode = firstReady.pairing.url
|
|
|
|
const addedRepo = await callClient(pairingCode, 'repo.add', { path: projectPath })
|
|
assertOk(addedRepo, 'fixture repo registration')
|
|
const worktreeList = await callClient(pairingCode, 'worktree.detectedList', {
|
|
repo: `id:${addedRepo.result.repo.id}`
|
|
})
|
|
assertOk(worktreeList, 'fixture worktree discovery')
|
|
const fixtureWorktree = worktreeList.result.worktrees.find(
|
|
(candidate) => candidate.repoId === addedRepo.result.repo.id
|
|
)
|
|
if (!fixtureWorktree) {
|
|
throw new Error(
|
|
`fixture worktree was not discovered: ${JSON.stringify(worktreeList.result.worktrees)}`
|
|
)
|
|
}
|
|
const worktree = `id:${fixtureWorktree.id}`
|
|
const resumeRequest = {
|
|
kind: 'explicit',
|
|
worktree,
|
|
agent: 'codex',
|
|
providerSession: { key: 'session_id', id: 'remote-authority-repro' },
|
|
presentation: 'background'
|
|
}
|
|
|
|
const [first, second] = await Promise.all([
|
|
callClient(pairingCode, 'terminal.ensureAgentSession', resumeRequest),
|
|
callClient(pairingCode, 'terminal.ensureAgentSession', resumeRequest)
|
|
])
|
|
assertOk(first, 'first racing resume')
|
|
assertOk(second, 'second racing resume')
|
|
const dispositions = [first.result.disposition, second.result.disposition].sort()
|
|
assertJsonEqual(dispositions, ['adopted', 'created'], 'race dispositions')
|
|
assertSameTerminal(first.result.terminal, second.result.terminal)
|
|
await waitFor(() => countSpawnMarkers() === 1, 'exactly one fixture agent spawn')
|
|
|
|
const retry = await callClient(pairingCode, 'terminal.ensureAgentSession', resumeRequest)
|
|
assertOk(retry, 'resume retry')
|
|
if (retry.result.disposition !== 'adopted') {
|
|
throw new Error(`resume retry was ${retry.result.disposition}, expected adopted`)
|
|
}
|
|
assertSameTerminal(first.result.terminal, retry.result.terminal)
|
|
if (countSpawnMarkers() !== 1) {
|
|
throw new Error('resume retry started a second agent')
|
|
}
|
|
|
|
const closed = await callClient(pairingCode, 'terminal.close', {
|
|
terminal: first.result.terminal.handle
|
|
})
|
|
assertOk(closed, 'fixture terminal close')
|
|
await waitFor(async () => {
|
|
const [terminals, tabs] = await Promise.all([
|
|
callClient(pairingCode, 'terminal.list', { worktree }),
|
|
callClient(pairingCode, 'session.tabs.list', { worktree })
|
|
])
|
|
return (
|
|
terminals.ok &&
|
|
tabs.ok &&
|
|
terminals.result.terminals.length === 0 &&
|
|
tabs.result.tabs.length === 0
|
|
)
|
|
}, 'exited surface retirement')
|
|
|
|
const oldTerminal = first.result.terminal
|
|
if (oldTerminal.tabId && oldTerminal.paneKey) {
|
|
const leafId = oldTerminal.paneKey.slice(oldTerminal.paneKey.indexOf(':') + 1)
|
|
await callClient(pairingCode, 'session.tabs.updatePaneLayout', {
|
|
worktree,
|
|
tabId: oldTerminal.tabId,
|
|
root: { type: 'leaf', id: leafId, ptyId: oldTerminal.ptyId ?? undefined }
|
|
}).catch(() => null)
|
|
}
|
|
|
|
const [afterStaleTerminals, afterStaleTabs] = await Promise.all([
|
|
callClient(pairingCode, 'terminal.list', { worktree }),
|
|
callClient(pairingCode, 'session.tabs.list', { worktree })
|
|
])
|
|
assertOk(afterStaleTerminals, 'terminal list after stale publication')
|
|
assertOk(afterStaleTabs, 'tab list after stale publication')
|
|
assertJsonEqual(afterStaleTerminals.result.terminals, [], 'terminal stale-write resurrection')
|
|
assertJsonEqual(afterStaleTabs.result.tabs, [], 'tab stale-write resurrection')
|
|
|
|
await stopServer()
|
|
const restarted = await startServer(port)
|
|
const restartPairingCode = restarted.pairing.url
|
|
const [afterRestartTerminals, afterRestartTabs] = await Promise.all([
|
|
callClient(restartPairingCode, 'terminal.list', { worktree }),
|
|
callClient(restartPairingCode, 'session.tabs.list', { worktree })
|
|
])
|
|
assertOk(afterRestartTerminals, 'terminal list after restart')
|
|
assertOk(afterRestartTabs, 'tab list after restart')
|
|
assertJsonEqual(afterRestartTerminals.result.terminals, [], 'terminal resurrection after restart')
|
|
assertJsonEqual(afterRestartTabs.result.tabs, [], 'tab resurrection after restart')
|
|
|
|
process.stdout.write(
|
|
'PASS remote agent-session authority: one spawn, retry adoption, durable exit retirement, no restart resurrection\n'
|
|
)
|
|
} finally {
|
|
await stopServer().catch(() => {})
|
|
for (const child of childProcesses) {
|
|
child.kill()
|
|
}
|
|
rmSync(scratch, { recursive: true, force: true })
|
|
}
|
|
|
|
function installFixtureAgent(targetDir) {
|
|
const nodePath = process.execPath
|
|
if (process.platform === 'win32') {
|
|
const commandPath = path.join(targetDir, 'codex.cmd')
|
|
writeFileSync(commandPath, `@"${nodePath}" "${fixtureScript}" %*\r\n`)
|
|
return commandPath
|
|
}
|
|
const commandPath = path.join(targetDir, 'codex')
|
|
writeFileSync(
|
|
commandPath,
|
|
`#!/bin/sh\nexec ${shellQuote(nodePath)} ${shellQuote(fixtureScript)} "$@"\n`
|
|
)
|
|
chmodSync(commandPath, 0o755)
|
|
return commandPath
|
|
}
|
|
|
|
function quoteFixtureAgentCommand(commandPath) {
|
|
return process.platform === 'win32'
|
|
? `"${commandPath.replaceAll('"', '""')}"`
|
|
: shellQuote(commandPath)
|
|
}
|
|
|
|
function shellQuote(value) {
|
|
return `'${value.replaceAll("'", `'\\''`)}'`
|
|
}
|
|
|
|
async function reservePort() {
|
|
return await new Promise((resolve, reject) => {
|
|
const listener = net.createServer()
|
|
listener.once('error', reject)
|
|
listener.listen(0, '127.0.0.1', () => {
|
|
const address = listener.address()
|
|
const port = typeof address === 'object' && address ? address.port : 0
|
|
listener.close((error) => (error ? reject(error) : resolve(port)))
|
|
})
|
|
})
|
|
}
|
|
|
|
async function startServer(port) {
|
|
const electronPath = await import('electron').then((module) => module.default)
|
|
const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === 'path') ?? 'PATH'
|
|
const pathDelimiter = process.platform === 'win32' ? ';' : ':'
|
|
const env = {
|
|
...process.env,
|
|
[pathKey]: `${binPath}${pathDelimiter}${process.env[pathKey] ?? ''}`,
|
|
ORCA_DEV_USER_DATA_PATH: profilePath,
|
|
ORCA_USER_DATA_PATH: profilePath,
|
|
ORCA_REPRO_SPAWN_MARKER: spawnMarkerPath,
|
|
ORCA_REPRO_EXIT_TRIGGER: exitTriggerPath,
|
|
...(process.platform === 'linux' ? { ELECTRON_DISABLE_SANDBOX: '1' } : {})
|
|
}
|
|
server = spawn(
|
|
electronPath,
|
|
[
|
|
repoRoot,
|
|
'--serve',
|
|
'--serve-json',
|
|
'--serve-port',
|
|
String(port),
|
|
'--serve-pairing-address',
|
|
`127.0.0.1:${port}`
|
|
],
|
|
{ cwd: repoRoot, env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }
|
|
)
|
|
childProcesses.add(server)
|
|
let stderr = ''
|
|
server.stderr.on('data', (chunk) => {
|
|
stderr += String(chunk)
|
|
})
|
|
const lines = createInterface({ input: server.stdout })
|
|
return await new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => {
|
|
reject(new Error(`server readiness timed out\n${stderr}`))
|
|
}, 30_000)
|
|
lines.on('line', (line) => {
|
|
try {
|
|
const parsed = JSON.parse(line)
|
|
if (parsed.type === 'orca_server_ready' && parsed.pairing?.url) {
|
|
clearTimeout(timeout)
|
|
resolve(parsed)
|
|
}
|
|
} catch {
|
|
// Startup diagnostics are allowed before the one structured ready line.
|
|
}
|
|
})
|
|
server.once('exit', (code) => {
|
|
clearTimeout(timeout)
|
|
reject(new Error(`server exited before readiness with code ${code}\n${stderr}`))
|
|
})
|
|
server.once('error', reject)
|
|
})
|
|
}
|
|
|
|
async function stopServer() {
|
|
const current = server
|
|
server = null
|
|
if (!current) {
|
|
return
|
|
}
|
|
childProcesses.delete(current)
|
|
if (current.exitCode !== null) {
|
|
return
|
|
}
|
|
current.kill('SIGTERM')
|
|
await new Promise((resolve) => {
|
|
const timeout = setTimeout(() => {
|
|
current.kill('SIGKILL')
|
|
resolve()
|
|
}, 8_000)
|
|
current.once('exit', () => {
|
|
clearTimeout(timeout)
|
|
resolve()
|
|
})
|
|
})
|
|
}
|
|
|
|
async function callClient(pairingCode, method, params) {
|
|
return await new Promise((resolve, reject) => {
|
|
const child = spawn(
|
|
process.execPath,
|
|
[clientScript, pairingCode, method, JSON.stringify(params)],
|
|
{ cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }
|
|
)
|
|
childProcesses.add(child)
|
|
let stdout = ''
|
|
let stderr = ''
|
|
child.stdout.on('data', (chunk) => {
|
|
stdout += String(chunk)
|
|
})
|
|
child.stderr.on('data', (chunk) => {
|
|
stderr += String(chunk)
|
|
})
|
|
child.once('error', reject)
|
|
child.once('exit', (code) => {
|
|
childProcesses.delete(child)
|
|
try {
|
|
const response = JSON.parse(stdout.trim())
|
|
if (code !== 0 && response.ok !== false) {
|
|
reject(new Error(`client ${method} exited ${code}: ${stderr}`))
|
|
return
|
|
}
|
|
resolve(response)
|
|
} catch (error) {
|
|
reject(
|
|
new Error(`client ${method} returned invalid JSON: ${stdout}\n${stderr}`, {
|
|
cause: error
|
|
})
|
|
)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
function countSpawnMarkers() {
|
|
if (!existsSync(spawnMarkerPath)) {
|
|
return 0
|
|
}
|
|
return readFileSync(spawnMarkerPath, 'utf8').split(/\r?\n/).filter(Boolean).length
|
|
}
|
|
|
|
async function waitFor(predicate, description) {
|
|
const deadline = Date.now() + 15_000
|
|
let lastError = null
|
|
while (Date.now() < deadline) {
|
|
try {
|
|
if (await predicate()) {
|
|
return
|
|
}
|
|
} catch (error) {
|
|
lastError = error
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 100))
|
|
}
|
|
throw new Error(`timed out waiting for ${description}`, { cause: lastError })
|
|
}
|
|
|
|
function assertOk(response, description) {
|
|
if (!response?.ok) {
|
|
throw new Error(`${description} failed: ${JSON.stringify(response)}`)
|
|
}
|
|
}
|
|
|
|
function assertSameTerminal(left, right) {
|
|
assertJsonEqual(
|
|
[left.handle, left.tabId, left.paneKey, left.ptyId],
|
|
[right.handle, right.tabId, right.paneKey, right.ptyId],
|
|
'canonical terminal identity'
|
|
)
|
|
}
|
|
|
|
function assertJsonEqual(actual, expected, description) {
|
|
if (JSON.stringify(actual) !== JSON.stringify(expected)) {
|
|
throw new Error(
|
|
`${description}: expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}`
|
|
)
|
|
}
|
|
}
|