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 { Project } from '../../shared/types'
import type { GitHubControlState } from '../../shared/github-issues'
import { GitHubHostController, GitHubHostError } from './host'
import type { TokenValidation } from './credentials'
const project: Project = {
id: 'project-1',
name: 'Test',
color: '#8b5cf6',
cwd: '/repo',
viewport: { x: 0, y: 0, zoom: 1 },
nodes: [],
kanban: {
columns: [
{ id: 'todo', title: 'Todo', color: '#2563eb' },
{ id: 'done', title: 'Done', color: '#16a34a' }
],
assignments: [],
github: {
columnMappings: [
{ columnId: 'todo', label: 'status:todo' },
{ columnId: 'done', label: 'status:done' }
],
completionColumnId: 'done'
}
}
}
function fixture(options: {
onRevoked?: (projectId: string) => Promise<void>
onApprovalChanged?: (projectId: string) => void
} = {}) {
let current: Project = project
let state: GitHubControlState = {
version: 1,
revision: 0,
authProvider: 'auto',
approvals: []
}
let token = 'secret'
const secret = {
availability: 'encrypted' as const,
readForHost: vi.fn(async () => token || null),
save: vi.fn(async (value: string) => { token = value }),
clear: vi.fn(async () => { token = '' })
}
const controls = {
load: vi.fn(async () => structuredClone(state)),
isApproved: vi.fn((current: GitHubControlState, input: {
localApprovalId: string
projectId: string
repository: string
}) => current.approvals.some((item) => item.localApprovalId === input.localApprovalId &&
item.projectId === input.projectId && item.repository === input.repository)),
isMappingApproved: vi.fn((current: GitHubControlState, input: {
localApprovalId: string
projectId: string
repository: string
mappingDigest: string
}) => current.approvals.some((item) => item.localApprovalId === input.localApprovalId &&
item.projectId === input.projectId && item.repository === input.repository &&
item.mappingDigest === input.mappingDigest)),
approve: vi.fn(async (input: {
expectedRevision: number
localApprovalId: string
projectId: string
repository: string
mappingDigest?: string
}) => {
state = {
...state,
revision: state.revision + 1,
approvals: [{ ...input, enabled: true as const, approvedAt: 1 }]
}
return structuredClone(state)
}),
revoke: vi.fn(async () => {
state = { ...state, revision: state.revision + 1, approvals: [] }
return structuredClone(state)
}),
selectProvider: vi.fn(async (input: { provider: 'auto' | 'gh' | 'token' }) => {
state = { ...state, revision: state.revision + 1, authProvider: input.provider }
return structuredClone(state)
})
}
const resolver = {
status: vi.fn(async (provider: 'auto' | 'gh' | 'token') => ({
selectedProvider: provider,
activeProvider: token ? 'token' as const : null,
ghAuthenticated: false,
tokenPresent: !!token,
storage: secret.availability,
...(token ? { login: 'octocat' } : {})
})),
resolve: vi.fn(async () => token ? {
provider: 'token' as const,
token,
userId: '1',
login: 'octocat'
} : null)
}
const client = {
listIssues: vi.fn(),
issuesHeartbeat: vi.fn(),
getIssue: vi.fn(),
updateIssue: vi.fn(),
listRepositoryLabels: vi.fn(),
createLabel: vi.fn(),
createIssue: vi.fn(),
createIssueComment: vi.fn()
}
const controller = new GitHubHostController({
project: vi.fn(async (id: string) => id === current.id
? { project: current, localApprovalId: 'local-private-id' }
: null),
detectRepository: vi.fn(async () => 'owner/repo'),
controls,
resolver,
secret,
validateToken: vi.fn(async (value: string): Promise<TokenValidation> => value === 'valid-token'
? { status: 'ok', identity: { userId: '1', login: 'octocat' } }
: value === 'unchecked-token'
? { status: 'unknown', reason: 'unreachable' }
: { status: 'unauthorized' }),
client: vi.fn(() => client),
...(options.onRevoked ? { onRevoked: options.onRevoked } : {}),
...(options.onApprovalChanged ? { onApprovalChanged: options.onApprovalChanged } : {}),
rate: (userId: string) => userId === '1'
? {
status: { resource: 'core', limit: 5_000, remaining: 7, resetAt: 9, observedAt: 1 },
throttle: { until: 9, kind: 'low-budget' as const }
}
: {}
})
return {
controller, controls, resolver, secret, client,
setProject: (next: Project) => { current = next },
setState: (next: GitHubControlState) => { state = next }
}
}
describe('GitHubHostController', () => {
it('returns a status view without tokens, approvals, or the local approval id', async () => {
const { controller, resolver } = fixture()
const view = await controller.status('project-1')
expect(view).toMatchObject({
control: { revision: 0, authProvider: 'auto' },
project: { repository: 'owner/repo', detectedRepository: 'owner/repo', approved: false }
})
expect(JSON.stringify(view)).not.toMatch(/secret|local-private-id|approvals/i)
expect(resolver.status).not.toHaveBeenCalled()
})
it('strips the resolver identity from the wire and attaches that identity rate budget', async () => {
const { controller, resolver } = fixture()
resolver.status.mockResolvedValueOnce({
selectedProvider: 'auto', activeProvider: 'token', ghAuthenticated: false,
tokenPresent: true, storage: 'encrypted', login: 'octocat', userId: '1'
} as never)
const view = await controller.status()
expect(view.auth).not.toHaveProperty('userId')
expect(view.rate).toEqual({ resource: 'core', limit: 5_000, remaining: 7, resetAt: 9, observedAt: 1 })
expect(view.throttle).toEqual({ until: 9, kind: 'low-budget' })
})
it('requires exact local approval before creating a service context', async () => {
const { controller } = fixture()
await expect(controller.contextForProject('project-1')).rejects.toMatchObject({ code: 'not-approved' })
await controller.approve({ projectId: 'project-1', repository: 'owner/repo', expectedRevision: 0 })
const context = await controller.contextForProject('project-1')
expect(context).toMatchObject({
projectId: 'project-1',
repository: 'owner/repo',
userId: '1',
columnColors: { todo: '#2563eb', done: '#16a34a' }
})
})
it('stops writes when a pulled commit changes the column mapping, until this machine approves it again', async () => {
const { controller, setProject } = fixture()
await controller.approve({ projectId: 'project-1', repository: 'owner/repo', expectedRevision: 0 })
expect((await controller.contextForProject('project-1')).mappingApproved).toBe(true)
// The completion column now closes issues from "Todo" — nobody on this machine agreed to that.
setProject({ ...project, kanban: { ...project.kanban!, github: {
...project.kanban!.github!, completionColumnId: 'todo'
} } })
const changed = await controller.contextForProject('project-1')
expect(changed.mappingApproved).toBe(false)
const view = await controller.status('project-1')
expect(view.project).toMatchObject({ approved: true, mappingApproved: false })
await controller.approve({ projectId: 'project-1', repository: 'owner/repo', expectedRevision: 1 })
expect((await controller.contextForProject('project-1')).mappingApproved).toBe(true)
expect((await controller.status('project-1')).project?.mappingApproved).toBe(true)
})
it('keeps reading under an approval from before mappings were bound, but never writes under it', async () => {
const { controller, setState } = fixture()
setState({
version: 1, revision: 4, authProvider: 'auto',
approvals: [{
localApprovalId: 'local-private-id', projectId: 'project-1', repository: 'owner/repo',
enabled: true, approvedAt: 1
}]
})
const context = await controller.projectContextForCache('project-1')
expect(context.mappingApproved).toBe(false)
// The resolved project rides the cache context, so the `issues` / `prs` control verbs load the
// workspace once per call (core/github/control-read.ts).
expect(context.project?.id).toBe('project-1')
expect((await controller.status('project-1')).project).toMatchObject({ approved: true, mappingApproved: false })
})
it('revokes first and then clears the cache, and says so when the cache could not be cleared', async () => {
const order: string[] = []
const { controller, controls } = fixture({
onRevoked: async (projectId: string) => { order.push(`clear:${projectId}`); throw new Error('EBUSY') }
})
controls.revoke.mockImplementationOnce(async () => {
order.push('revoke')
return { version: 1, revision: 1, authProvider: 'auto', approvals: [] }
})
await expect(controller.revoke({ projectId: 'project-1', expectedRevision: 0 }))
.rejects.toMatchObject({ code: 'revoked-cache-kept' })
expect(order).toEqual(['revoke', 'clear:project-1'])
})
it('tells open boards the approval changed, on approve and on a revoke whose cache clear failed', async () => {
const changed = vi.fn()
const { controller } = fixture({
onApprovalChanged: changed,
onRevoked: async () => { throw new Error('EBUSY') }
})
await controller.approve({ projectId: 'project-1', repository: 'owner/repo', expectedRevision: 0 })
expect(changed).toHaveBeenCalledWith('project-1')
changed.mockClear()
// A successful clear already prompts the board (it empties the cache it shows); a failed one
// does not, and the board must still learn it is no longer approved.
await expect(controller.revoke({ projectId: 'project-1', expectedRevision: 1 }))
.rejects.toMatchObject({ code: 'revoked-cache-kept' })
expect(changed).toHaveBeenCalledWith('project-1')
})
it('rejects approval for a repository other than the configured or detected repository', async () => {
const { controller } = fixture()
await expect(controller.approve({
projectId: 'project-1', repository: 'other/repo', expectedRevision: 0
})).rejects.toBeInstanceOf(GitHubHostError)
})
it('validates a token before saving and never returns it', async () => {
const { controller, secret } = fixture()
await expect(controller.saveToken('bad')).rejects.toMatchObject({ code: 'invalid-token' })
expect(secret.save).not.toHaveBeenCalled()
const view = await controller.saveToken('valid-token')
expect(secret.save).toHaveBeenCalledWith('valid-token')
expect(JSON.stringify(view)).not.toContain('valid-token')
})
it('does not call a token invalid when GitHub could not be asked, and saves nothing', async () => {
const { controller, secret } = fixture()
await expect(controller.saveToken('unchecked-token')).rejects.toMatchObject({ code: 'github-unreachable' })
expect(secret.save).not.toHaveBeenCalled()
})
})