chore: apply pr-reviewer fixes for #140

Author: agent-relay-code[bot]

src/main/broker.test.ts

@@ -32,29 +32,42 @@ type MockClient = {
   brokerPid?: number
   baseUrl?: string
   agentNames: string[]
+  agentRuntimes: Record<string, 'pty' | 'headless'>
 }
 
 const mock = vi.hoisted(() => {
   function createMockClient(agentNames: string[] = []): MockClient {
+    const agentRuntimes = Object.fromEntries(agentNames.map((name) => [name, 'pty' as const]))
     const client: MockClient = {
       agentNames: [...agentNames],
+      agentRuntimes,
       getSession: vi.fn(async () => ({})),
-      listAgents: vi.fn(async () => client.agentNames.map((name) => ({ name, runtime: 'pty', channels: [] }))),
+      listAgents: vi.fn(async () => client.agentNames.map((name) => ({
+        name,
+        runtime: client.agentRuntimes[name] || 'pty',
+        channels: []
+      }))),
       getInboundDeliveryMode: vi.fn(async () => 'passthrough'),
       spawnPty: vi.fn(async (input: { name: string }) => {
         client.agentNames.push(input.name)
+        client.agentRuntimes[input.name] = 'pty'
         return { name: input.name, runtime: 'pty' }
       }),
       spawnCli: vi.fn(async (input: { name: string }) => {
         client.agentNames.push(input.name)
+        client.agentRuntimes[input.name] = 'headless'
         return { name: input.name, runtime: 'headless' }
       }),
       setInboundDeliveryMode: vi.fn(async (_name: string, mode: string) => ({ mode, flushed: 0 })),
       snapshot: vi.fn(async () => ({ rows: 24, cols: 80, cursor: { x: 0, y: 0 }, screen: 'aGVsbG8=' })),
       resizePty: vi.fn(async () => undefined),
       getPending: vi.fn(async () => []),
       getStatus: vi.fn(async () => ({
-        agents: client.agentNames.map((name) => ({ name, runtime: 'pty', channels: [] })),
+        agents: client.agentNames.map((name) => ({
+          name,
+          runtime: client.agentRuntimes[name] || 'pty',
+          channels: []
+        })),
         pending_delivery_count: 0
       })),
       onEvent: vi.fn(() => () => undefined),
@@ -542,6 +555,60 @@ describe('BrokerManager local + cloud coexistence', () => {
     await manager.shutdown()
   })
 
+  it('spawns OpenCode with headless runtime and skips PTY attach operations', async () => {
+    const manager = new BrokerManager()
+    const local = await startLocal(manager, [])
+
+    const spawned = await manager.spawnAgent(PROJECT_ID, { name: 'opencode-1', cli: 'opencode' })
+    const attached = await manager.attachTerminal(PROJECT_ID, {
+      name: spawned.name,
+      mode: 'passthrough',
+      rows: 24,
+      cols: 80
+    })
+
+    expect(spawned).toEqual({ name: 'opencode-1', runtime: 'headless' })
+    expect(local.spawnCli).toHaveBeenCalledWith(expect.objectContaining({
+      name: 'opencode-1',
+      cli: expect.stringContaining('opencode'),
+      transport: 'headless'
+    }))
+    expect(local.spawnPty).not.toHaveBeenCalled()
+    expect(local.resizePty).not.toHaveBeenCalled()
+    expect(local.snapshot).not.toHaveBeenCalled()
+    expect(attached).toEqual({
+      name: 'opencode-1',
+      mode: 'auto_inject',
+      previousMode: 'passthrough',
+      pending: 0,
+      runtime: 'headless'
+    })
+
+    await manager.shutdown()
+  })
+
+  it('remembers headless runtime from discovered agents before attaching', async () => {
+    const manager = new BrokerManager()
+    const local = await startLocal(manager, [])
+    local.listAgents.mockResolvedValue([
+      { name: 'opencode-1', runtime: 'headless', channels: [] }
+    ])
+
+    const attached = await manager.attachTerminal(PROJECT_ID, {
+      name: 'opencode-1',
+      mode: 'passthrough',
+      rows: 24,
+      cols: 80
+    })
+
+    expect(local.setInboundDeliveryMode).toHaveBeenCalledWith('opencode-1', 'auto_inject')
+    expect(local.resizePty).not.toHaveBeenCalled()
+    expect(local.snapshot).not.toHaveBeenCalled()
+    expect(attached.runtime).toBe('headless')
+
+    await manager.shutdown()
+  })
+
   it('coalesces concurrent duplicate spawn requests', async () => {
     const manager = new BrokerManager()
     const local = await startLocal(manager, [])

src/main/broker.ts

@@ -323,6 +323,7 @@ export interface AttachTerminalResult {
   mode: InboundDeliveryMode
   previousMode?: InboundDeliveryMode
   pending: number
+  runtime?: 'pty' | 'headless'
   snapshot?: {
     rows: number
     cols: number
@@ -2050,7 +2051,6 @@ export class BrokerManager {
       } else if (event.kind === 'agent_exit' && event.name) {
         this.closeInputStream(this.getInputStreamKey(sessionKey, event.name), 1000, 'agent closed')
         this.forgetAgentSession(event.name, sessionKey)
-        this.agentRuntimes.delete(event.name)
         void client.release(event.name, 'agent exit').catch((err) => {
           if (!isMissingAgentError(err)) {
             console.warn(`[broker] Failed to release exited agent ${event.name}:`, err)
@@ -2059,7 +2059,6 @@ export class BrokerManager {
       } else if ((event.kind === 'agent_exited' || event.kind === 'agent_released') && event.name) {
         this.closeInputStream(this.getInputStreamKey(sessionKey, event.name), 1000, 'agent closed')
         this.forgetAgentSession(event.name, sessionKey)
-        this.agentRuntimes.delete(event.name)
       } else if ('name' in event && typeof event.name === 'string') {
         this.rememberAgentSession(event.name, sessionKey)
       } else if ('from' in event && typeof event.from === 'string') {
@@ -2193,12 +2192,19 @@ export class BrokerManager {
     this.agentSessions.set(name, sessionKeys)
   }
 
+  private rememberAgentRuntime(agent: Pick<ListAgent, 'name' | 'runtime'>): void {
+    if (agent.runtime === 'pty' || agent.runtime === 'headless') {
+      this.agentRuntimes.set(agent.name, agent.runtime)
+    }
+  }
+
   private forgetAgentSession(name: string, sessionKey: string): void {
     const sessionKeys = this.agentSessions.get(name)
     if (!sessionKeys) return
     sessionKeys.delete(sessionKey)
     if (sessionKeys.size === 0) {
       this.agentSessions.delete(name)
+      this.agentRuntimes.delete(name)
     }
   }
 
@@ -2554,7 +2560,11 @@ export class BrokerManager {
     while (Date.now() < deadline) {
       try {
         const agents = await session.client.listAgents()
-        if (agents.some((agent) => agent.name === name)) return true
+        const agent = agents.find((candidate) => candidate.name === name)
+        if (agent) {
+          this.rememberAgentRuntime(agent)
+          return true
+        }
       } catch {
         // Transient broker errors during the wait are fine — keep polling
         // until the deadline; if the broker is genuinely down the downstream
@@ -2586,8 +2596,10 @@ export class BrokerManager {
     while (Date.now() < deadline) {
       for (const candidate of candidates) {
         const agents = await candidate.client.listAgents().catch(() => null)
-        if (agents?.some((agent) => agent.name === name)) {
+        const agent = agents?.find((entry) => entry.name === name)
+        if (agent) {
           this.rememberAgentSession(name, sessionKeyFor(candidate))
+          this.rememberAgentRuntime(agent)
           return { session: candidate, registered: true }
         }
       }
@@ -3281,6 +3293,7 @@ export class BrokerManager {
     const sessionKey = sessionKeyFor(session)
     for (const agent of agents) {
       this.rememberAgentSession(agent.name, sessionKey)
+      this.rememberAgentRuntime(agent)
     }
     const brokerKind = session.cloudSandboxId ? ('cloud' as const) : ('local' as const)
     return Promise.all(
@@ -3461,6 +3474,7 @@ export class BrokerManager {
       sessionKeys.delete(sessionKey)
       if (sessionKeys.size === 0) {
         this.agentSessions.delete(agentName)
+        this.agentRuntimes.delete(agentName)
       }
     }
   }

src/shared/types/ipc.ts

@@ -369,6 +369,7 @@ export interface BrokerAttachTerminalResult {
   mode: InboundDeliveryMode
   previousMode?: InboundDeliveryMode
   pending: number
+  runtime?: 'pty' | 'headless'
   snapshot?: {
     rows: number
     cols: number