mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
* fix(agent-hooks): give resumed Claude sessions a sidebar row at SessionStart (STA-3386) Claude's hook set never registered SessionStart and normalizeClaudeEvent dropped it at ingest, so a resumed session that idled produced zero hook traffic and earned no sidebar agent row until the first prompt. - Register SessionStart in CLAUDE_EVENTS (local + remote installs). - Map lead SessionStart (startup/resume/clear) to an idle 'done' row, resetting stale roster/task/cron/tool/prompt state like the Codex path; compact restarts and child-attributed SessionStart stay dropped. - Thread hookEventName through the agent-status IPC payload so the completion coordinator can tell a session connect from a turn result; a SessionStart 'done' no longer raises agent-task-complete. * fix(agent-hooks): mark SessionStart rows as session boundaries, not completions (STA-3386) Review follow-up: represent the idle connect as a first-class sessionBoundary flag on the status payload instead of gating one renderer consumer on hookEventName. - sessionBoundary rides AgentStatusPayload/AgentStatusEntry (done-only, clamped like interrupted); drops the hookEventName IPC threading. - Completion-reactive consumers ignore session boundaries: the completion coordinator (task-complete notifications), automation dispatch observers (a connecting agent no longer completes the run and closes its tab), activity unread counts, and the dashboard finished timestamp; the status slice keeps boundaries out of stateHistory and preserves the flag across done->done repaints. - SessionStart sources are allowlisted (startup/resume/clear) so compact restarts or unknown sources fail closed mid-turn. - A live SessionStart now un-retires a reusable pane like a fresh prompt, so resume-in-reused-pane earns its row too. * fix(agent-hooks): keep session-boundary dones out of teardown and completion history (STA-3386) Review round 2: - A boundary done no longer deletes the pane's launch-config registry entry, so a resumed idle TUI keeps its registered-launch-agent identity evidence. - A boundary landing on a REAL done pushes that completion into stateHistory so the finished timestamp and unread badge survive a resume//clear right after a finish. - The done->done flag carry yields to turn evidence (assistant message or changed prompt) so a genuine completion can never be suppressed. - Star-nag value-moment observer and the server's OSC-equivalence dedupe now discriminate the flag. * fix(agent-hooks): keep a displaced completion unread in the sidebar badge (STA-3386) Review round 3: sidebar-badge mode counts only the live entry, so a session boundary landing on an unacknowledged completion silently dropped the sidebar badge while the agent-events count kept it. Count the displaced completion from history for boundary rows, and pin the behavior with countActivityUnread tests. * fix(agent-hooks): prevent SessionStart completion side effects (STA-3386) * fix(agent-hooks): preserve SessionStart through renderer IPC (STA-3386)
166 lines
4.6 KiB
TypeScript
166 lines
4.6 KiB
TypeScript
import type { AddressInfo } from 'node:net'
|
|
import { afterEach, describe, expect, it } from 'vitest'
|
|
import { WebSocketServer, type WebSocket } from 'ws'
|
|
import { encodePairingOffer, parsePairingCode, type PairingOffer } from './pairing'
|
|
import {
|
|
decrypt,
|
|
deriveSharedKey,
|
|
encrypt,
|
|
generateKeyPair,
|
|
publicKeyFromBase64,
|
|
publicKeyToBase64
|
|
} from './e2ee-crypto'
|
|
import { RemoteRuntimeRequestConnection } from './remote-runtime-request-connection'
|
|
import {
|
|
AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY,
|
|
SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY
|
|
} from './protocol-version'
|
|
|
|
type TestServer = {
|
|
wss: WebSocketServer
|
|
pairing: PairingOffer
|
|
requests: unknown[]
|
|
auths: unknown[]
|
|
connectionCount: () => number
|
|
}
|
|
|
|
const servers: WebSocketServer[] = []
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(
|
|
servers.splice(0).map(
|
|
(server) =>
|
|
new Promise<void>((resolve) => {
|
|
for (const client of server.clients) {
|
|
client.close()
|
|
}
|
|
server.close(() => resolve())
|
|
})
|
|
)
|
|
)
|
|
})
|
|
|
|
describe('RemoteRuntimeRequestConnection', () => {
|
|
it('reuses one encrypted WebSocket for multiple one-shot RPCs', async () => {
|
|
const server = await createServer()
|
|
const connection = new RemoteRuntimeRequestConnection(server.pairing)
|
|
|
|
const first = await connection.request('status.get', undefined, 1000)
|
|
const second = await connection.request('terminal.send', { terminal: 't1', text: 'ab' }, 1000)
|
|
|
|
expect(first).toMatchObject({
|
|
ok: true,
|
|
result: { method: 'status.get' },
|
|
_meta: { runtimeId: 'runtime-test' }
|
|
})
|
|
expect(second).toMatchObject({
|
|
ok: true,
|
|
result: { method: 'terminal.send' },
|
|
_meta: { runtimeId: 'runtime-test' }
|
|
})
|
|
expect(server.connectionCount()).toBe(1)
|
|
expect(server.auths).toContainEqual(
|
|
expect.objectContaining({
|
|
clientCapabilities: [
|
|
SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
|
|
AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY
|
|
]
|
|
})
|
|
)
|
|
expect(server.requests).toMatchObject([
|
|
{ method: 'status.get' },
|
|
{ method: 'terminal.send', params: { terminal: 't1', text: 'ab' } }
|
|
])
|
|
|
|
connection.close()
|
|
})
|
|
})
|
|
|
|
async function createServer(): Promise<TestServer> {
|
|
const serverKeyPair = generateKeyPair()
|
|
const requests: unknown[] = []
|
|
const auths: unknown[] = []
|
|
let connectionCount = 0
|
|
const wss = new WebSocketServer({ port: 0 })
|
|
servers.push(wss)
|
|
|
|
wss.on('connection', (ws) => {
|
|
connectionCount += 1
|
|
let sharedKey: Uint8Array | null = null
|
|
let authenticated = false
|
|
|
|
ws.on('message', (data, isBinary) => {
|
|
if (isBinary) {
|
|
return
|
|
}
|
|
const frame = data.toString()
|
|
if (!sharedKey) {
|
|
const hello = JSON.parse(frame) as { type: string; publicKeyB64: string }
|
|
const clientPublicKey = publicKeyFromBase64(hello.publicKeyB64)
|
|
sharedKey = deriveSharedKey(serverKeyPair.secretKey, clientPublicKey)
|
|
ws.send(JSON.stringify({ type: 'e2ee_ready' }))
|
|
return
|
|
}
|
|
|
|
const plaintext = decrypt(frame, sharedKey)
|
|
if (plaintext === null) {
|
|
return
|
|
}
|
|
if (!authenticated) {
|
|
const auth = JSON.parse(plaintext) as { type: string; deviceToken: string }
|
|
auths.push(auth)
|
|
expect(auth).toEqual({
|
|
type: 'e2ee_auth',
|
|
deviceToken: 'device-token',
|
|
clientCapabilities: [
|
|
SESSION_TAB_CLOSE_INTENT_RUNTIME_CAPABILITY,
|
|
AGENT_SESSION_BOUNDARY_RUNTIME_CAPABILITY
|
|
]
|
|
})
|
|
authenticated = true
|
|
sendEncrypted(ws, sharedKey, { type: 'e2ee_authenticated' })
|
|
return
|
|
}
|
|
|
|
const request = JSON.parse(plaintext) as {
|
|
id: string
|
|
method: string
|
|
params?: unknown
|
|
}
|
|
requests.push(request)
|
|
sendEncrypted(ws, sharedKey, {
|
|
id: request.id,
|
|
ok: true,
|
|
result: { method: request.method },
|
|
_meta: { runtimeId: 'runtime-test' }
|
|
})
|
|
})
|
|
})
|
|
|
|
await new Promise<void>((resolve) => wss.once('listening', resolve))
|
|
const address = wss.address() as AddressInfo
|
|
const pairing = parsePairingCode(
|
|
encodePairingOffer({
|
|
v: 2,
|
|
endpoint: `ws://127.0.0.1:${address.port}`,
|
|
deviceToken: 'device-token',
|
|
publicKeyB64: publicKeyToBase64(serverKeyPair.publicKey)
|
|
})
|
|
)
|
|
if (!pairing) {
|
|
throw new Error('Failed to create test pairing')
|
|
}
|
|
|
|
return {
|
|
wss,
|
|
pairing,
|
|
requests,
|
|
auths,
|
|
connectionCount: () => connectionCount
|
|
}
|
|
}
|
|
|
|
function sendEncrypted(ws: WebSocket, sharedKey: Uint8Array, message: unknown): void {
|
|
ws.send(encrypt(JSON.stringify(message), sharedKey))
|
|
}
|