@recombine-ai/bosun 0.16.2 → 0.17.1

package/src/backend/git-mode/command.ts

@@ -0,0 +1,405 @@
+import { randomUUID } from 'node:crypto'
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+
+export interface CommandResult {
+	stdout: string
+	stderr: string
+	stdoutBuffer?: Buffer
+	stderrBuffer?: Buffer
+	exitCode: number
+}
+
+export interface CommandOptions {
+	cwd: string
+	env?: NodeJS.ProcessEnv
+	input?: string | Buffer
+	timeoutMs?: number
+	acceptedExitCodes?: readonly number[]
+}
+
+export type CommandRunner = (
+	executable: string,
+	args: readonly string[],
+	options: CommandOptions
+) => Promise<CommandResult>
+
+export interface CommandSupervisor {
+	run: CommandRunner
+	shutdown(): Promise<void>
+	activeCount(): number
+}
+
+export class CommandError extends Error {
+	readonly executable: string
+	readonly args: readonly string[]
+	readonly result: CommandResult
+
+	constructor(executable: string, args: readonly string[], result: CommandResult) {
+		super(
+			`${executable} exited with code ${result.exitCode}${result.stderr.trim() ? `: ${result.stderr.trim()}` : ''}`
+		)
+		this.name = 'CommandError'
+		this.executable = executable
+		this.args = args
+		this.result = result
+	}
+}
+
+interface CommandLedgerProcess {
+	pid: number
+	processGroupId: number
+	executable: string
+	startedAt: string
+}
+
+interface CommandLedger {
+	version: 1
+	leaseId: string
+	launchId: string
+	repositoryRoot: string
+	processes: CommandLedgerProcess[]
+}
+
+interface ActiveCommand {
+	child: ChildProcessWithoutNullStreams
+	closed: Promise<void>
+	resolveClosed: () => void
+	ledgerProcess: CommandLedgerProcess
+}
+
+const DEFAULT_TIMEOUT_MS = 2 * 60 * 1000
+const MAX_OUTPUT_BYTES = 4 * 1024 * 1024
+const COMPLETION_GRACE_MS = 3_000
+const TERMINATE_GRACE_MS = 3_000
+const KILL_CONFIRM_MS = 5_000
+const DESCENDANT_EXIT_GRACE_MS = 100
+
+export function createCommandSupervisor(options?: {
+	commandStatePath?: string
+	leaseId?: string
+	completionGraceMs?: number
+	terminateGraceMs?: number
+	killConfirmMs?: number
+}): CommandSupervisor {
+	const commandStatePath = options?.commandStatePath?.trim() || null
+	const leaseId = options?.leaseId?.trim() || null
+	if (Boolean(commandStatePath) !== Boolean(leaseId)) {
+		throw new Error('Git command supervision requires both a command-state path and lease ID.')
+	}
+	if (commandStatePath && leaseId) readCommandLedger(commandStatePath, leaseId)
+
+	const active = new Map<number, ActiveCommand>()
+	let accepting = true
+	let shutdownPromise: Promise<void> | null = null
+
+	const persistActiveCommands = (): void => {
+		if (!commandStatePath || !leaseId) return
+		const ledger = readCommandLedger(commandStatePath, leaseId)
+		ledger.processes = [...active.values()].map((entry) => entry.ledgerProcess)
+		writeCommandLedger(commandStatePath, ledger)
+	}
+
+	const run: CommandRunner = (executable, args, commandOptions) => {
+		if (!accepting) {
+			return Promise.reject(new Error(`Bosun is shutting down; ${executable} was not started.`))
+		}
+
+		return new Promise((resolve, reject) => {
+			const child = spawn(executable, [...args], {
+				cwd: commandOptions.cwd,
+				env: commandOptions.env,
+				detached: process.platform !== 'win32',
+				stdio: ['pipe', 'pipe', 'pipe'],
+				windowsHide: true
+			})
+			const stdoutChunks: Buffer[] = []
+			const stderrChunks: Buffer[] = []
+			let outputBytes = 0
+			let settled = false
+			let timedOut = false
+			let outputLimitExceeded = false
+			let pendingError: Error | null = null
+
+			let resolveClosed = () => {}
+			const closed = new Promise<void>((resolveClose) => {
+				resolveClosed = resolveClose
+			})
+			const pid = child.pid
+			if (pid !== undefined) {
+				active.set(pid, {
+					child,
+					closed,
+					resolveClosed,
+					ledgerProcess: {
+						pid,
+						processGroupId: pid,
+						executable,
+						startedAt: new Date().toISOString()
+					}
+				})
+				try {
+					persistActiveCommands()
+				} catch (error) {
+					pendingError = asError(error)
+					signalChild(child, 'SIGKILL')
+				}
+			}
+
+			const timer = setTimeout(() => {
+				timedOut = true
+				signalChild(child, 'SIGKILL')
+			}, commandOptions.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+			timer.unref()
+
+			const capture = (target: Buffer[], chunk: Buffer) => {
+				outputBytes += chunk.length
+				if (outputBytes > MAX_OUTPUT_BYTES) {
+					outputLimitExceeded = true
+					signalChild(child, 'SIGKILL')
+					return
+				}
+				target.push(chunk)
+			}
+
+			child.stdout.on('data', (chunk: Buffer) => capture(stdoutChunks, chunk))
+			child.stderr.on('data', (chunk: Buffer) => capture(stderrChunks, chunk))
+			child.stdin.on('error', (error: NodeJS.ErrnoException) => {
+				if (error.code === 'EPIPE' || settled) return
+				pendingError = error
+				signalChild(child, 'SIGKILL')
+			})
+			child.once('error', (error) => {
+				pendingError = error
+				if (child.pid === undefined) void finish(null, null)
+				else {
+					signalChild(child, 'SIGKILL')
+				}
+			})
+			child.once('close', (code, signal) => void finish(code, signal))
+
+			if (commandOptions.input === undefined) child.stdin.end()
+			else child.stdin.end(commandOptions.input)
+
+			async function finish(code: number | null, signal: NodeJS.Signals | null): Promise<void> {
+				if (settled) return
+				settled = true
+				clearTimeout(timer)
+				let processGroupError: Error | null = null
+				if (pid !== undefined && process.platform !== 'win32') {
+					await waitForProcessGroupExit(pid, DESCENDANT_EXIT_GRACE_MS)
+					if (isProcessGroupAlive(pid)) {
+						const backgroundProcessError = new Error(
+							`${executable} left background processes in repository command group ${pid}; Bosun terminated them.`
+						)
+						pendingError ??= backgroundProcessError
+						signalProcessGroup(pid, 'SIGTERM')
+						await waitForProcessGroupExit(pid, options?.terminateGraceMs ?? TERMINATE_GRACE_MS)
+						if (isProcessGroupAlive(pid)) {
+							signalProcessGroup(pid, 'SIGKILL')
+							await waitForProcessGroupExit(pid, options?.killConfirmMs ?? KILL_CONFIRM_MS)
+						}
+						if (isProcessGroupAlive(pid)) {
+							processGroupError = new Error(
+								`Bosun could not confirm termination of repository command process group ${pid}.`
+							)
+						}
+					}
+				}
+
+				if (processGroupError) {
+					pendingError = processGroupError
+					reject(processGroupError)
+					return
+				}
+				if (pid !== undefined) active.delete(pid)
+				let ledgerError: Error | null = null
+				try {
+					persistActiveCommands()
+				} catch (error) {
+					ledgerError = asError(error)
+				}
+				resolveClosed()
+
+				if (ledgerError) {
+					reject(ledgerError)
+					return
+				}
+				if (pendingError) {
+					reject(pendingError)
+					return
+				}
+				if (timedOut) {
+					reject(
+						new Error(
+							`${executable} timed out after ${commandOptions.timeoutMs ?? DEFAULT_TIMEOUT_MS} ms`
+						)
+					)
+					return
+				}
+				if (outputLimitExceeded) {
+					reject(new Error(`${executable} produced more than ${MAX_OUTPUT_BYTES} bytes of output`))
+					return
+				}
+
+				const stdoutBuffer = Buffer.concat(stdoutChunks)
+				const stderrBuffer = Buffer.concat(stderrChunks)
+				const result: CommandResult = {
+					stdout: stdoutBuffer.toString('utf8'),
+					stderr: stderrBuffer.toString('utf8'),
+					stdoutBuffer,
+					stderrBuffer,
+					exitCode: code ?? (signal ? 128 : 1)
+				}
+				if (!(commandOptions.acceptedExitCodes ?? [0]).includes(result.exitCode)) {
+					reject(new CommandError(executable, args, result))
+					return
+				}
+				resolve(result)
+			}
+		})
+	}
+
+	const shutdown = (): Promise<void> => {
+		if (shutdownPromise) return shutdownPromise
+		accepting = false
+		shutdownPromise = (async () => {
+			// Starting the next command is already forbidden. Give a command that is currently at a
+			// Give the current Git/pnpm boundary a short opportunity to finish naturally, then stop
+			// the whole process group. Once every group is confirmed dead and the ledger is empty,
+			// shutdown is safe; interrupted operations themselves still reject their caller.
+			await waitForActiveCommands(active, options?.completionGraceMs ?? COMPLETION_GRACE_MS)
+			for (const command of active.values()) signalChild(command.child, 'SIGTERM')
+			await waitForActiveCommands(active, options?.terminateGraceMs ?? TERMINATE_GRACE_MS)
+
+			if (active.size > 0) {
+				for (const command of active.values()) signalChild(command.child, 'SIGKILL')
+				await waitForActiveCommands(active, options?.killConfirmMs ?? KILL_CONFIRM_MS)
+			}
+
+			if (active.size > 0) {
+				throw new Error(
+					`Bosun could not confirm termination of repository command PIDs ${[...active.keys()].join(', ')}.`
+				)
+			}
+			persistActiveCommands()
+		})()
+		return shutdownPromise
+	}
+
+	return { run, shutdown, activeCount: () => active.size }
+}
+
+const defaultSupervisor = createCommandSupervisor()
+export const runCommand: CommandRunner = defaultSupervisor.run
+
+async function waitForActiveCommands(
+	active: Map<number, ActiveCommand>,
+	timeoutMs: number
+): Promise<void> {
+	const closures = [...active.values()].map((entry) => entry.closed)
+	if (closures.length === 0) return
+	await Promise.race([
+		Promise.allSettled(closures),
+		new Promise<void>((resolve) => {
+			const timer = setTimeout(resolve, timeoutMs)
+			timer.unref()
+		})
+	])
+}
+
+function signalChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): boolean {
+	const pid = child.pid
+	if (pid === undefined) return false
+	if (process.platform !== 'win32') return signalProcessGroup(pid, signal)
+	try {
+		return child.kill(signal)
+	} catch (error) {
+		return isNodeError(error, 'ESRCH')
+	}
+}
+
+function signalProcessGroup(processGroupId: number, signal: NodeJS.Signals): boolean {
+	try {
+		process.kill(-processGroupId, signal)
+		return true
+	} catch (error) {
+		return isNodeError(error, 'ESRCH')
+	}
+}
+
+function isProcessGroupAlive(processGroupId: number): boolean {
+	try {
+		process.kill(-processGroupId, 0)
+		return true
+	} catch (error) {
+		return !isNodeError(error, 'ESRCH')
+	}
+}
+
+async function waitForProcessGroupExit(processGroupId: number, timeoutMs: number): Promise<void> {
+	const deadline = Date.now() + timeoutMs
+	while (isProcessGroupAlive(processGroupId) && Date.now() < deadline) {
+		await new Promise((resolve) => setTimeout(resolve, 20))
+	}
+}
+
+function readCommandLedger(path: string, expectedLeaseId: string): CommandLedger {
+	const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+	if (!isCommandLedger(parsed) || parsed.leaseId !== expectedLeaseId) {
+		throw new Error(`Bosun cannot verify repository command ownership at ${path}.`)
+	}
+	return parsed
+}
+
+function writeCommandLedger(path: string, ledger: CommandLedger): void {
+	const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`
+	let operationError: Error | null = null
+	try {
+		writeFileSync(temporaryPath, `${JSON.stringify(ledger)}\n`, {
+			encoding: 'utf8',
+			flag: 'wx',
+			mode: 0o600
+		})
+		renameSync(temporaryPath, path)
+	} catch (error) {
+		operationError = asError(error)
+	}
+	try {
+		unlinkSync(temporaryPath)
+	} catch (error) {
+		if (!isNodeError(error, 'ENOENT')) operationError = asError(error)
+	}
+	if (operationError) throw operationError
+}
+
+function isCommandLedger(value: unknown): value is CommandLedger {
+	if (!value || typeof value !== 'object') return false
+	const ledger = value as Partial<CommandLedger>
+	return (
+		ledger.version === 1 &&
+		typeof ledger.leaseId === 'string' &&
+		typeof ledger.launchId === 'string' &&
+		typeof ledger.repositoryRoot === 'string' &&
+		Array.isArray(ledger.processes) &&
+		ledger.processes.every(
+			(entry) =>
+				entry &&
+				typeof entry === 'object' &&
+				Number.isSafeInteger(entry.pid) &&
+				entry.pid > 0 &&
+				Number.isSafeInteger(entry.processGroupId) &&
+				entry.processGroupId > 0 &&
+				typeof entry.executable === 'string' &&
+				typeof entry.startedAt === 'string'
+		)
+	)
+}
+
+function asError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error))
+}
+
+function isNodeError(error: unknown, code: string): boolean {
+	return error instanceof Error && 'code' in error && error.code === code
+}

package/src/backend/git-mode/config.spec.ts

@@ -0,0 +1,45 @@
+import path from 'node:path'
+
+import { describe, expect, it } from 'vitest'
+
+import { readGitModeConfig } from './config'
+
+describe('readGitModeConfig', () => {
+	it('does not require Git settings while the launcher has not enabled Git mode', () => {
+		expect(readGitModeConfig({ env: {}, projectDir: '/tmp/project' })).toMatchObject({
+			enabled: false,
+			projectDir: path.resolve('/tmp/project')
+		})
+	})
+
+	it('reads the normalized launcher-only environment contract', () => {
+		const config = readGitModeConfig({
+			env: {
+				BOSUN_GIT_MODE: 'true',
+				BOSUN_CURRENT_BRANCH: 'next-release',
+				BOSUN_PERSONAL_BRANCH: 'sb/bosun',
+				BOSUN_GIT_ACTIVATION_IDLE_MS: '1234',
+				BOSUN_GIT_REPOSITORY_ROOT: '/tmp/project',
+				BOSUN_GIT_CURRENT_UPSTREAM: 'origin/next-release',
+				BOSUN_GIT_CURRENT_UPSTREAM_REMOTE: 'origin',
+				BOSUN_GIT_CURRENT_UPSTREAM_BRANCH: 'next-release',
+				BOSUN_GIT_PERSONAL_UPSTREAM: 'origin/sb/bosun',
+				BOSUN_GIT_PERSONAL_UPSTREAM_REMOTE: 'origin',
+				BOSUN_GIT_PERSONAL_UPSTREAM_BRANCH: 'sb/bosun',
+				BOSUN_GIT_LAUNCH_ID: 'launch-id',
+				BOSUN_GIT_RUNTIME_STATE_PATH: '/tmp/runtime/state.json',
+				BOSUN_GIT_ACTIVATION_RESTART_EXIT_CODE: '76'
+			}
+		})
+
+		expect(config).toMatchObject({
+			enabled: true,
+			idleMs: 1234,
+			currentBranch: 'next-release',
+			personalBranch: 'sb/bosun',
+			currentUpstreamRemote: 'origin',
+			personalUpstreamRemote: 'origin',
+			restartExitCode: 76
+		})
+	})
+})

package/src/backend/git-mode/config.ts

@@ -0,0 +1,90 @@
+import path from 'node:path'
+
+import type { GitModeConfig } from './types'
+
+const DEFAULT_IDLE_MS = 10 * 60 * 1000
+const DEFAULT_RESTART_EXIT_CODE = 76
+
+export function readGitModeConfig(options?: {
+	env?: NodeJS.ProcessEnv
+	projectDir?: string
+}): GitModeConfig {
+	const env = options?.env ?? process.env
+	const enabled = env.BOSUN_GIT_MODE === 'true'
+	const projectDir = path.resolve(
+		enabled
+			? requireValue(env, 'BOSUN_GIT_REPOSITORY_ROOT')
+			: (options?.projectDir ?? process.cwd())
+	)
+
+	if (!enabled) {
+		return {
+			enabled: false,
+			projectDir,
+			currentBranch: '',
+			personalBranch: '',
+			idleMs: DEFAULT_IDLE_MS,
+			currentUpstream: '',
+			currentUpstreamRemote: '',
+			currentUpstreamBranch: '',
+			personalUpstream: '',
+			personalUpstreamRemote: '',
+			personalUpstreamBranch: '',
+			launchId: '',
+			runtimeStatePath: '',
+			restartExitCode: DEFAULT_RESTART_EXIT_CODE
+		}
+	}
+
+	const idleMs = readPositiveInteger(env.BOSUN_GIT_ACTIVATION_IDLE_MS, DEFAULT_IDLE_MS, {
+		name: 'BOSUN_GIT_ACTIVATION_IDLE_MS',
+		allowZero: true
+	})
+	const restartExitCode = readPositiveInteger(
+		env.BOSUN_GIT_ACTIVATION_RESTART_EXIT_CODE,
+		DEFAULT_RESTART_EXIT_CODE,
+		{ name: 'BOSUN_GIT_ACTIVATION_RESTART_EXIT_CODE', max: 255 }
+	)
+
+	return {
+		enabled: true,
+		projectDir,
+		currentBranch: requireValue(env, 'BOSUN_CURRENT_BRANCH'),
+		personalBranch: requireValue(env, 'BOSUN_PERSONAL_BRANCH'),
+		idleMs,
+		currentUpstream: requireValue(env, 'BOSUN_GIT_CURRENT_UPSTREAM'),
+		currentUpstreamRemote: requireValue(env, 'BOSUN_GIT_CURRENT_UPSTREAM_REMOTE'),
+		currentUpstreamBranch: requireValue(env, 'BOSUN_GIT_CURRENT_UPSTREAM_BRANCH'),
+		personalUpstream: requireValue(env, 'BOSUN_GIT_PERSONAL_UPSTREAM'),
+		personalUpstreamRemote: requireValue(env, 'BOSUN_GIT_PERSONAL_UPSTREAM_REMOTE'),
+		personalUpstreamBranch: requireValue(env, 'BOSUN_GIT_PERSONAL_UPSTREAM_BRANCH'),
+		launchId: requireValue(env, 'BOSUN_GIT_LAUNCH_ID'),
+		runtimeStatePath: path.resolve(requireValue(env, 'BOSUN_GIT_RUNTIME_STATE_PATH')),
+		restartExitCode
+	}
+}
+
+function requireValue(env: NodeJS.ProcessEnv, name: string): string {
+	const value = env[name]?.trim()
+	if (!value) throw new Error(`${name} is required when BOSUN_GIT_MODE=true`)
+	return value
+}
+
+function readPositiveInteger(
+	raw: string | undefined,
+	fallback: number,
+	options: { name: string; allowZero?: boolean; max?: number }
+): number {
+	if (raw === undefined || raw === '') return fallback
+
+	const value = Number(raw)
+	const minimum = options.allowZero ? 0 : 1
+	if (
+		!Number.isSafeInteger(value) ||
+		value < minimum ||
+		value > (options.max ?? Number.MAX_SAFE_INTEGER)
+	) {
+		throw new Error(`Invalid ${options.name}: ${raw}`)
+	}
+	return value
+}

package/src/backend/git-mode/index.ts

@@ -0,0 +1,20 @@
+export { readGitModeConfig } from './config'
+export { createGitModeRouter } from './router'
+export {
+	createGitModeService,
+	createPullRequestUrl,
+	parseGitHubRepository,
+	type GitModeServiceDependencies
+} from './service'
+export type {
+	ActivationReason,
+	ChangeAction,
+	ChangeChoice,
+	GitModeConfig,
+	GitModeFatal,
+	GitModeFatalKind,
+	GitModePhase,
+	GitModePreparationStage,
+	GitModeService,
+	GitModeStatus
+} from './types'

package/src/backend/git-mode/repository-write-gate.spec.ts

@@ -0,0 +1,116 @@
+import { mkdir, mkdtemp, readFile, rm, unlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { RepositoryWriteGate, RepositoryWritesPausedError } from './repository-write-gate'
+
+const temporaryDirectories: string[] = []
+
+afterEach(async () => {
+	await Promise.all(
+		temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true }))
+	)
+})
+
+describe('RepositoryWriteGate', () => {
+	it('locks out new cross-process writes and drains a previously admitted write', async () => {
+		const config = await createConfig('lease-a', 'launch-a')
+		const backendGate = new RepositoryWriteGate(config)
+		const frontendGate = new RepositoryWriteGate(config)
+		await backendGate.initializeBackend()
+
+		let releaseWrite!: () => void
+		let markStarted!: () => void
+		const started = new Promise<void>((resolve) => (markStarted = resolve))
+		const write = frontendGate.withWriteAdmission(async () => {
+			markStarted()
+			await new Promise<void>((resolve) => (releaseWrite = resolve))
+		})
+		await started
+
+		const drained = vi.fn()
+		const locking = backendGate.lockAndDrain().then(drained)
+		await new Promise((resolve) => setTimeout(resolve, 50))
+		expect(drained).not.toHaveBeenCalled()
+		await expect(frontendGate.withWriteAdmission(async () => {})).rejects.toBeInstanceOf(
+			RepositoryWritesPausedError
+		)
+
+		releaseWrite()
+		await Promise.all([write, locking])
+		expect(drained).toHaveBeenCalledOnce()
+	})
+
+	it('idempotently unlocks its owned gate and admits writes again', async () => {
+		const config = await createConfig('lease-a', 'launch-a')
+		const backendGate = new RepositoryWriteGate(config)
+		const frontendGate = new RepositoryWriteGate(config)
+		await backendGate.initializeBackend()
+		await backendGate.lockAndDrain()
+
+		await expect(frontendGate.withWriteAdmission(async () => {})).rejects.toBeInstanceOf(
+			RepositoryWritesPausedError
+		)
+		await backendGate.unlock()
+		await backendGate.unlock()
+
+		await expect(frontendGate.withWriteAdmission(async () => 'written')).resolves.toBe('written')
+	})
+
+	it('refuses to remove a lock whose ownership changed while it was held', async () => {
+		const config = await createConfig('lease-a', 'launch-a')
+		const gate = new RepositoryWriteGate(config)
+		await gate.initializeBackend()
+		await gate.lockAndDrain()
+		const lockPath = path.join(config.projectDir, '.git', 'bosun-write-gate.lock.json')
+		const replacement = {
+			version: 1,
+			leaseId: 'different-lease',
+			launchId: 'different-launch',
+			pid: process.pid,
+			createdAt: new Date().toISOString()
+		}
+		await writeFile(lockPath, `${JSON.stringify(replacement)}\n`)
+
+		await expect(gate.unlock()).rejects.toThrow(/no longer owns/)
+		expect(JSON.parse(await readFile(lockPath, 'utf8'))).toEqual(replacement)
+	})
+
+	it('fails closed if its owned lock disappears before unlock', async () => {
+		const config = await createConfig('lease-a', 'launch-a')
+		const gate = new RepositoryWriteGate(config)
+		await gate.initializeBackend()
+		await gate.lockAndDrain()
+		await unlink(path.join(config.projectDir, '.git', 'bosun-write-gate.lock.json'))
+
+		await expect(gate.unlock()).rejects.toThrow(/no longer owns/)
+	})
+
+	it('recovers a persisted lock after a new launcher lease following shutdown', async () => {
+		const firstConfig = await createConfig('lease-before-shutdown', 'launch-before-shutdown')
+		const firstBackend = new RepositoryWriteGate(firstConfig)
+		await firstBackend.initializeBackend()
+		await firstBackend.lockAndDrain()
+
+		const restartedConfig = {
+			...firstConfig,
+			leaseId: 'lease-after-restart',
+			launchId: 'launch-after-restart'
+		}
+		const restartedBackend = new RepositoryWriteGate(restartedConfig)
+		await restartedBackend.initializeBackend()
+
+		await expect(
+			new RepositoryWriteGate(restartedConfig).withWriteAdmission(async () => 'written')
+		).resolves.toBe('written')
+	})
+})
+
+async function createConfig(leaseId: string, launchId: string) {
+	const projectDir = await mkdtemp(path.join(tmpdir(), 'bosun-write-gate-'))
+	temporaryDirectories.push(projectDir)
+	await mkdir(path.join(projectDir, '.git'))
+	return { enabled: true, projectDir, leaseId, launchId }
+}