Node-based terminal manager for AI coding agents — tmux-backed terminals and parallel agent sessions as draggable nodes on an infinite pan/zoom canvas. macOS, Linux, and a browser Server Edition.
TypeScript adhdagent-orchestrationai-agentscanvasclaude-codecodexcoding-agentsdeveloper-toolselectrongeminilinuxmacosmultiplexeropencodeparallel-agentsterminalterminal-emulatorterminal-multiplexertmuxworkspace-manager
import { describe, expect, it, vi } from 'vitest'
import type { CanvasNodeState } from '../shared/types'
import type { TriggerSpec } from '../shared/trigger'
import { createTriggerDelivery, type TriggerDeliveryDeps } from './trigger-delivery'
import type { TriggerRow, TriggerRun } from './trigger-scheduler'
const spec = (payload = 'npm run report'): TriggerSpec => ({
schedule: { kind: 'cron', expr: '0 9 * * *' },
payload,
target: 'term-tgt-1'
})
const row = (payload?: string): TriggerRow => ({
projectId: 'project-1',
nodeId: 'trigger-a-1',
spec: spec(payload)
})
interface World {
nodes: Map<string, Partial<CanvasNodeState>>
state: string | undefined
pane: string | null
sent: Array<{ nodeId: string; text: string }>
sendOk: boolean
armed: boolean
triggerSpec: TriggerSpec | undefined
runs: Array<{ nodeId: string; run: TriggerRun }>
timers: Array<{ ms: number; fn: () => void }>
delivery: ReturnType<typeof createTriggerDelivery>
deps: TriggerDeliveryDeps
}
function world(overrides: Partial<TriggerDeliveryDeps> = {}): World {
const w = {
nodes: new Map<string, Partial<CanvasNodeState>>([
['term-tgt-1', { agentId: 'claude' }]
]),
state: 'done' as string | undefined,
pane: null as string | null,
sent: [] as Array<{ nodeId: string; text: string }>,
sendOk: true,
armed: true,
triggerSpec: spec() as TriggerSpec | undefined,
runs: [] as Array<{ nodeId: string; run: TriggerRun }>,
timers: [] as Array<{ ms: number; fn: () => void }>
}
const deps: TriggerDeliveryDeps = {
sendText: vi.fn(async (nodeId: string, text: string) => {
if (w.sendOk) w.sent.push({ nodeId, text })
return w.sendOk
}),
paneCommand: async () => w.pane,
agentState: () => (w.state === undefined ? undefined : { state: w.state }),
targetNode: (nodeId) => w.nodes.get(nodeId) as CanvasNodeState | undefined,
currentSpec: () => w.triggerSpec,
isArmed: () => w.armed,
schedule: (ms, fn) => {
const t = { ms, fn }
w.timers.push(t)
return () => {
const i = w.timers.indexOf(t)
if (i >= 0) w.timers.splice(i, 1)
}
},
...overrides
}
const delivery = createTriggerDelivery(deps)
delivery.setRunSink((_p, nodeId, run) => w.runs.push({ nodeId, run }))
// Attach onto the SAME object the dep closures capture — a spread copy would let a test mutate
// fields the delivery never reads.
return Object.assign(w, { delivery, deps })
}
describe('trigger delivery — immediate outcomes', () => {
it('records an unsubmitted paste as a terminal miss with no retry', async () => {
const sendText = vi.fn(async () => 'pasted-not-submitted' as const)
const w = world({ sendText })
const result = await w.delivery.fire(row())
expect(result.outcome).toBe('missed')
expect(result.detail).toContain('Do not resend')
expect(sendText).toHaveBeenCalledTimes(1)
})
it('delivers into an idle (done) agent target', async () => {
const w = world()
const r = await w.delivery.fire(row())
expect(r.outcome).toBe('fired')
expect(w.sent).toEqual([{ nodeId: 'term-tgt-1', text: 'npm run report' }])
})
it('a gone target is missed — nothing sent', async () => {
const w = world()
w.nodes.clear()
const r = await w.delivery.fire(row())
expect(r.outcome).toBe('missed')
expect(r.detail).toMatch(/no longer exists/)
expect(w.sent).toHaveLength(0)
})
it('a dead session is missed (sendText false)', async () => {
const w = world()
w.sendOk = false
const r = await w.delivery.fire(row())
expect(r.outcome).toBe('missed')
expect(r.detail).toMatch(/not running/)
})
it('a plain terminal delivers only into a SHELL pane, and is never queued', async () => {
const w = world()
w.nodes.set('term-tgt-1', {}) // no agentId
w.pane = 'zsh'
expect((await w.delivery.fire(row())).outcome).toBe('fired')
w.pane = 'vim'
const busy = await w.delivery.fire(row())
expect(busy.outcome).toBe('missed')
expect(busy.detail).toContain("running 'vim'")
w.pane = null
expect((await w.delivery.fire(row())).outcome).toBe('missed')
// One successful send total — the vim and null-pane attempts typed nothing.
expect(w.sent).toHaveLength(1)
})
it('a plain terminal on the Windows session host delivers into pwsh.exe / cmd.exe', async () => {
const w = world()
w.nodes.set('term-tgt-1', {}) // no agentId
for (const pane of ['pwsh.exe', 'cmd.exe']) {
w.pane = pane
expect((await w.delivery.fire(row())).outcome, pane).toBe('fired')
}
w.pane = 'node.exe'
expect((await w.delivery.fire(row())).outcome).toBe('missed')
expect(w.sent).toHaveLength(2)
})
it('a busy agent target queues; an unknown agent state queues too', async () => {
const w = world()
w.state = 'working'
const busy = await w.delivery.fire(row())
expect(busy.outcome).toBe('queued')
expect(busy.detail).toContain('working')
w.state = undefined
const unknown = await w.delivery.fire(row('second payload'))
expect(unknown.outcome).toBe('queued')
expect(w.sent).toHaveLength(0)
})
})
describe('trigger delivery — the deliver-on-idle queue', () => {
it('retains the partial-paste explanation after an idle queue flush and never retries', async () => {
const sendText = vi.fn(async () => 'pasted-not-submitted' as const)
const w = world({ sendText })
w.state = 'working'
expect((await w.delivery.fire(row())).outcome).toBe('queued')
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.runs[0].run).toMatchObject({ outcome: 'missed', detail: expect.stringContaining('Do not resend') })
await w.delivery.onTargetIdle('term-tgt-1')
expect(sendText).toHaveBeenCalledTimes(1)
})
it('flushes on the idle edge and reports delivered-late', async () => {
const w = world()
w.state = 'working'
expect((await w.delivery.fire(row())).outcome).toBe('queued')
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toEqual([{ nodeId: 'term-tgt-1', text: 'npm run report' }])
expect(w.runs.map((r) => r.run.outcome)).toEqual(['delivered-late'])
expect(w.runs[0].nodeId).toBe('trigger-a-1')
})
it('FLUSH-TIME RE-VALIDATION: disarmed while queued is dropped, never delivered', async () => {
const w = world()
w.state = 'working'
await w.delivery.fire(row())
w.armed = false // the user disarmed the trigger while its payload waited
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toHaveLength(0)
expect(w.runs.map((r) => r.run.outcome)).toEqual(['missed'])
expect(w.runs[0].run.detail).toMatch(/disarmed or edited/)
})
it('FLUSH-TIME RE-VALIDATION: a spec edited while queued is dropped', async () => {
const w = world()
w.state = 'working'
await w.delivery.fire(row())
w.triggerSpec = spec('some new payload') // git pull rewrote the trigger
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toHaveLength(0)
expect(w.runs.map((r) => r.run.outcome)).toEqual(['missed'])
})
it('a target still busy at flush is re-queued, then delivered on the next idle', async () => {
const w = world()
w.state = 'working'
await w.delivery.fire(row())
// The idle edge fires but the target picked up new work before the flush ran.
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toHaveLength(0)
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toHaveLength(1)
expect(w.runs.map((r) => r.run.outcome)).toEqual(['delivered-late'])
})
it('a queued payload that waits out its TTL expires with a run record, nothing sent', async () => {
const w = world()
w.state = 'working'
await w.delivery.fire(row())
expect(w.timers).toHaveLength(1)
w.timers[0].fn() // the TTL timer fires
await Promise.resolve()
expect(w.sent).toHaveLength(0)
expect(w.runs.map((r) => r.run.outcome)).toEqual(['expired'])
expect(w.runs[0].run.detail).toMatch(/never went idle/)
})
it('a target that disappears while queued is a missed run at flush', async () => {
const w = world()
w.state = 'working'
await w.delivery.fire(row())
w.nodes.clear()
w.state = 'done'
await w.delivery.onTargetIdle('term-tgt-1')
expect(w.sent).toHaveLength(0)
expect(w.runs.map((r) => r.run.outcome)).toEqual(['missed'])
expect(w.runs[0].run.detail).toMatch(/went away/)
})
})