@recombine-ai/bosun 0.17.1 → 0.20.0

package/src/lib/git-mode/GitControlsButton.svelte

@@ -1,96 +0,0 @@
-<script lang="ts">
-	import Button from '$lib/components/Button.svelte'
-	import { getGitModeContext } from './git-mode-context'
-
-	const gitMode = getGitModeContext()
-	const manualAction = $derived(gitMode.manualAction())
-	const busy = $derived(
-		manualAction !== null ||
-			gitMode.state.phase !== 'idle' ||
-			gitMode.isWritePaused() ||
-			gitMode.isActivationStarting()
-	)
-	const changeActionDisabled = $derived(!gitMode.state.hasChanges || busy)
-	const prepareDisabled = $derived(
-		gitMode.state.hasChanges || !gitMode.state.canPrepareRelease || busy
-	)
-	const changeActionDisabledMessage = $derived(
-		!gitMode.state.hasChanges
-			? 'No changes to save or discard'
-			: busy
-				? 'A Git operation is in progress'
-				: ''
-	)
-	const prepareDisabledMessage = $derived(
-		busy
-			? 'A Git operation is in progress'
-			: gitMode.state.hasChanges
-				? 'Save or discard changes before preparing for release'
-				: !gitMode.state.canPrepareRelease
-					? 'No changes to prepare for release'
-					: ''
-	)
-</script>
-
-{#if gitMode.state.enabled}
-	<div class="flex min-w-0 flex-wrap items-center justify-end gap-1">
-		<div class="group relative inline-flex" tabindex={changeActionDisabled ? 0 : undefined}>
-			<Button
-				variant="outlined"
-				size="small"
-				disabled={changeActionDisabled}
-				onclick={gitMode.openDiscardDialog}
-				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
-			>
-				{manualAction === 'discard' ? 'Discarding...' : 'Discard'}
-			</Button>
-			{#if changeActionDisabledMessage}
-				<div
-					role="tooltip"
-					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
-				>
-					{changeActionDisabledMessage}
-				</div>
-			{/if}
-		</div>
-
-		<div class="group relative inline-flex" tabindex={changeActionDisabled ? 0 : undefined}>
-			<Button
-				variant="secondary"
-				size="small"
-				disabled={changeActionDisabled}
-				onclick={gitMode.openSaveDialog}
-				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
-			>
-				{manualAction === 'save' ? 'Saving...' : 'Save'}
-			</Button>
-			{#if changeActionDisabledMessage}
-				<div
-					role="tooltip"
-					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
-				>
-					{changeActionDisabledMessage}
-				</div>
-			{/if}
-		</div>
-
-		<div class="group relative inline-flex" tabindex={prepareDisabled ? 0 : undefined}>
-			<Button
-				size="small"
-				disabled={prepareDisabled}
-				onclick={gitMode.prepareRelease}
-				class="whitespace-nowrap !px-2.5 !py-1 !text-sm"
-			>
-				{manualAction === 'prepare-release' ? 'Preparing...' : 'Prepare for release'}
-			</Button>
-			{#if prepareDisabledMessage}
-				<div
-					role="tooltip"
-					class="pointer-events-none absolute right-0 top-full z-40 mt-2 hidden w-max max-w-64 rounded-md border border-rc-gray-600 bg-rc-gray-800 px-3 py-2 text-xs font-normal text-rc-gray-100 shadow-xl group-hover:block group-focus:block"
-				>
-					{prepareDisabledMessage}
-				</div>
-			{/if}
-		</div>
-	</div>
-{/if}

package/src/lib/git-mode/client-admission.spec.ts

@@ -1,304 +0,0 @@
-import type { Operation, TRPCLink } from '@trpc/client'
-import { observable } from '@trpc/server/observable'
-import { describe, expect, it, vi } from 'vitest'
-
-import {
-	GIT_FLUSH_OPERATION_CONTEXT_KEY,
-	GitModeMutationBlockedError,
-	RepositoryClientAdmission,
-	isGitModeMutationBlockedError,
-	repositoryAdmissionLink
-} from './client-admission'
-import { GIT_MODE_USAGE_BLOCKED_MESSAGE } from './errors'
-
-type Envelope = { result: { type: 'data'; data: string } }
-
-function operation(
-	type: Operation['type'],
-	path: string,
-	context: Record<string, unknown> = {},
-	signal: AbortSignal | null = null
-): Operation {
-	return { id: 1, type, path, context, input: undefined, signal }
-}
-
-function execute(
-	admission: RepositoryClientAdmission,
-	op: Operation,
-	next: ReturnType<TRPCLink<any>> extends (options: infer Options) => unknown
-		? Options extends { next: infer Next }
-			? Next
-			: never
-		: never
-): Promise<Envelope> {
-	const link = repositoryAdmissionLink<any>(admission)({})
-	const result = link({ op, next } as never)
-	return new Promise((resolve, reject) => {
-		result.subscribe({
-			next: (value) => resolve(value as Envelope),
-			error: reject
-		})
-	})
-}
-
-function successfulNext(calls: string[]) {
-	return ((op: Operation) =>
-		observable<Envelope>((observer) => {
-			calls.push(op.path)
-			observer.next({ result: { type: 'data', data: op.path } })
-			observer.complete()
-		})) as any
-}
-
-describe('RepositoryClientAdmission link', () => {
-	it('allows Git control operations while initial admission is unknown', async () => {
-		const admission = new RepositoryClientAdmission()
-		const calls: string[] = []
-
-		await expect(
-			execute(admission, operation('mutation', 'gitMode.status'), successfulNext(calls))
-		).resolves.toMatchObject({ result: { data: 'gitMode.status' } })
-		expect(calls).toEqual(['gitMode.status'])
-	})
-
-	it('defers queries until admission opens', async () => {
-		const admission = new RepositoryClientAdmission()
-		const calls: string[] = []
-		const pending = execute(admission, operation('query', 'agents.catalog'), successfulNext(calls))
-
-		await Promise.resolve()
-		expect(calls).toEqual([])
-		admission.setState({ mode: 'open', flushOperationId: null })
-
-		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.catalog' } })
-		expect(calls).toEqual(['agents.catalog'])
-	})
-
-	it('rechecks admission before dispatching a query whose open waiter resolved', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		const calls: string[] = []
-		const pending = execute(admission, operation('query', 'agents.catalog'), successfulNext(calls))
-
-		await Promise.resolve()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		await Promise.resolve()
-		expect(calls).toEqual([])
-
-		admission.setState({ mode: 'open', flushOperationId: null })
-		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.catalog' } })
-		expect(calls).toEqual(['agents.catalog'])
-	})
-
-	it('allows an admitted mutation to complete after admission locks', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		const calls: string[] = []
-		let complete!: () => void
-		const next = ((op: Operation) =>
-			observable<Envelope>((observer) => {
-				calls.push(op.path)
-				complete = () => {
-					observer.next({ result: { type: 'data', data: op.path } })
-					observer.complete()
-				}
-			})) as any
-
-		const pending = execute(admission, operation('mutation', 'agents.suggestTestFix'), next)
-		await vi.waitFor(() => expect(calls).toEqual(['agents.suggestTestFix']))
-
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		complete()
-
-		await expect(pending).resolves.toMatchObject({ result: { data: 'agents.suggestTestFix' } })
-		expect(calls).toEqual(['agents.suggestTestFix'])
-	})
-
-	it('blocks and taints a mutation without calling the transport', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		const calls: string[] = []
-		const blocked = vi.fn()
-		admission.onBlockedMutation(blocked)
-
-		await expect(
-			execute(admission, operation('mutation', 'tests.patchTest'), successfulNext(calls))
-		).rejects.toSatisfy(isGitModeMutationBlockedError)
-		expect(calls).toEqual([])
-		expect(admission.isTainted()).toBe(true)
-		expect(blocked).toHaveBeenCalledWith('tests.patchTest')
-	})
-
-	it('notifies a listener registered after the tab was tainted', () => {
-		const admission = new RepositoryClientAdmission()
-		admission.blockMutation('tests.patchTest')
-		const blocked = vi.fn()
-
-		admission.onBlockedMutation(blocked)
-
-		expect(blocked).toHaveBeenCalledWith('tests.patchTest')
-	})
-
-	it('admits only the active flush token while quiescing', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'quiescing', flushOperationId: 'operation-1' })
-		const calls: string[] = []
-
-		await expect(
-			execute(
-				admission,
-				operation('mutation', 'agents.savePrompt', {
-					[GIT_FLUSH_OPERATION_CONTEXT_KEY]: 'operation-1'
-				}),
-				successfulNext(calls)
-			)
-		).resolves.toMatchObject({ result: { data: 'agents.savePrompt' } })
-		await expect(
-			execute(
-				admission,
-				operation('mutation', 'regionConfig.save', {
-					[GIT_FLUSH_OPERATION_CONTEXT_KEY]: 'operation-old'
-				}),
-				successfulNext(calls)
-			)
-		).rejects.toBeInstanceOf(Error)
-		expect(calls).toEqual(['agents.savePrompt'])
-	})
-
-	it('keeps deferring a repeatedly server-blocked query until admission reopens successfully', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		let attempts = 0
-		const next = (() =>
-			observable<Envelope>((observer) => {
-				attempts += 1
-				if (attempts <= 2) observer.error(new Error(GIT_MODE_USAGE_BLOCKED_MESSAGE))
-				else {
-					observer.next({ result: { type: 'data', data: 'recovered' } })
-					observer.complete()
-				}
-			})) as any
-
-		const pending = execute(admission, operation('query', 'agents.catalog'), next)
-		await Promise.resolve()
-		expect(admission.getState().mode).toBe('locked')
-		expect(attempts).toBe(1)
-
-		admission.setState({ mode: 'open', flushOperationId: null })
-		await vi.waitFor(() => expect(attempts).toBe(2))
-		expect(admission.getState().mode).toBe('locked')
-
-		admission.setState({ mode: 'open', flushOperationId: null })
-		await expect(pending).resolves.toMatchObject({ result: { data: 'recovered' } })
-		expect(attempts).toBe(3)
-	})
-
-	it('does not retry a genuine query error just because admission closed in flight', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		let attempts = 0
-		const next = (() =>
-			observable<Envelope>((observer) => {
-				attempts += 1
-				admission.setState({ mode: 'locked', flushOperationId: null })
-				observer.error(new Error('Invalid query input.'))
-			})) as any
-
-		await expect(
-			execute(admission, operation('query', 'agents.catalog'), next)
-		).rejects.toMatchObject({ message: 'Invalid query input.' })
-		admission.setState({ mode: 'open', flushOperationId: null })
-		await Promise.resolve()
-		expect(attempts).toBe(1)
-	})
-
-	it.each(['Failed to fetch', 'Load failed', 'NetworkError when attempting to fetch resource.'])(
-		'defers an in-flight query after the backend restart transport error: %s',
-		async (message) => {
-			const admission = new RepositoryClientAdmission()
-			admission.setState({ mode: 'open', flushOperationId: null })
-			let attempts = 0
-			const next = (() =>
-				observable<Envelope>((observer) => {
-					attempts += 1
-					if (attempts === 1) {
-						admission.setState({ mode: 'locked', flushOperationId: null })
-						observer.error(new Error('tRPC transport failed', { cause: new TypeError(message) }))
-						return
-					}
-					observer.next({ result: { type: 'data', data: 'recovered' } })
-					observer.complete()
-				})) as any
-
-			const pending = execute(admission, operation('query', 'agents.catalog'), next)
-			await Promise.resolve()
-			expect(attempts).toBe(1)
-
-			admission.setState({ mode: 'open', flushOperationId: null })
-			await expect(pending).resolves.toMatchObject({ result: { data: 'recovered' } })
-			expect(attempts).toBe(2)
-		}
-	)
-
-	it('does not retry a fetch transport error while repository admission remains open', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		let attempts = 0
-		const next = (() =>
-			observable<Envelope>((observer) => {
-				attempts += 1
-				observer.error(new TypeError('Failed to fetch'))
-			})) as any
-
-		await expect(
-			execute(admission, operation('query', 'agents.catalog'), next)
-		).rejects.toMatchObject({ message: 'Failed to fetch' })
-		expect(attempts).toBe(1)
-	})
-
-	it('does not notify an observer after a deferred query is unsubscribed', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		const calls: string[] = []
-		const error = vi.fn()
-		const link = repositoryAdmissionLink<any>(admission)({})
-		const result = link({
-			op: operation('query', 'agents.catalog'),
-			next: successfulNext(calls)
-		} as never)
-
-		const subscription = result.subscribe({ error })
-		subscription.unsubscribe()
-		await Promise.resolve()
-		admission.setState({ mode: 'open', flushOperationId: null })
-		await Promise.resolve()
-
-		expect(error).not.toHaveBeenCalled()
-		expect(calls).toEqual([])
-	})
-
-	it('rejects an already-aborted request instead of leaving it deferred', async () => {
-		const admission = new RepositoryClientAdmission()
-		admission.setState({ mode: 'locked', flushOperationId: null })
-		const calls: string[] = []
-		const controller = new AbortController()
-		controller.abort(new Error('Request was already aborted.'))
-
-		await expect(
-			execute(
-				admission,
-				operation('query', 'agents.catalog', {}, controller.signal),
-				successfulNext(calls)
-			)
-		).rejects.toMatchObject({ message: 'Request was already aborted.' })
-		expect(calls).toEqual([])
-	})
-
-	it('recognizes a wrapped blocked-mutation error', () => {
-		const wrapped = new Error('wrapped', {
-			cause: new GitModeMutationBlockedError('tests.addTest')
-		})
-		expect(isGitModeMutationBlockedError(wrapped)).toBe(true)
-	})
-})