@recombine-ai/bosun 0.18.0 → 0.20.0

package/src/backend/lib/get-agent-factories.ts

@@ -1,118 +0,0 @@
-import type { TestAgentFactory } from '@recombine-ai/bosun-lib'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import type { AgentCatalogEntry } from '../../lib/agent-catalog'
-
-export type BosunTestScope = 'global' | 'region'
-
-export type BosunAgentMeta = {
-	defaultRegion: string | null
-	availableRegions: string[]
-	testScope: BosunTestScope
-	displayName?: string
-}
-
-export type BosunResolvedTestSuite = {
-	suiteKey: string
-	resolvedRegion: string | null
-}
-
-export interface BosunProjectApiV1 {
-	version: 1
-	getAgentMeta(agentId: string): Promise<BosunAgentMeta>
-	resolveTestSuite(input: {
-		agentId: string
-		region?: string | null
-	}): Promise<BosunResolvedTestSuite>
-}
-
-export interface Project {
-	factories: Record<string, TestAgentFactory>
-	basePath: string
-	bosunApi?: BosunProjectApiV1
-}
-
-function fallbackAgentDisplayName(agentId: string): string {
-	return agentId.split('/').at(-1) || agentId
-}
-
-export async function getAgentCatalog(project: Project): Promise<AgentCatalogEntry[]> {
-	return Promise.all(
-		Object.keys(project.factories).map(async (id) => {
-			let displayName: string | undefined
-
-			if (project.bosunApi) {
-				try {
-					displayName = (await project.bosunApi.getAgentMeta(id)).displayName?.trim()
-				} catch (error) {
-					console.warn(
-						`Failed to load metadata for agent '${id}', using its id as the label.`,
-						error
-					)
-				}
-			}
-
-			return {
-				id,
-				displayName: displayName || fallbackAgentDisplayName(id)
-			}
-		})
-	)
-}
-
-function parseBosunProjectApi(candidate: unknown): BosunProjectApiV1 | undefined {
-	if (candidate == null) return undefined
-	if (typeof candidate !== 'object' || Array.isArray(candidate)) {
-		throw new Error('Invalid bosunApi export: expected an object')
-	}
-
-	const api = candidate as Partial<BosunProjectApiV1>
-	if (api.version !== 1) {
-		throw new Error('Invalid bosunApi export: expected version 1')
-	}
-	if (typeof api.getAgentMeta !== 'function') {
-		throw new Error('Invalid bosunApi export: missing getAgentMeta(agentId)')
-	}
-	if (typeof api.resolveTestSuite !== 'function') {
-		throw new Error('Invalid bosunApi export: missing resolveTestSuite(input)')
-	}
-
-	return api as BosunProjectApiV1
-}
-
-export async function getAgentFactories(agentsModule: string, importNonce?: number) {
-	const baseUrl = pathToFileURL(agentsModule).href
-	// IMPORTANT: The project's module graph (including `region-config.json`) is cached by the module loader.
-	// When Bosun edits `region-config.json`, we bump an "import nonce" and re-import the project entrypoint
-	// with a cache-busting query string so the updated JSON is picked up without restarting Bosun.
-	const modUrl =
-		typeof importNonce === 'number'
-			? (() => {
-					const u = new URL(baseUrl)
-					u.searchParams.set('bosunImportNonce', String(importNonce))
-					return u.href
-				})()
-			: baseUrl
-
-	let mod: any
-	try {
-		mod = await import(modUrl)
-	} catch (e) {
-		console.error('Failed to import agents module:', modUrl, e)
-	}
-
-	const basePath = mod?.basePath ?? path.dirname(agentsModule)
-	if (!mod?.basePath) {
-		console.warn(`Agents module does not export basePath; falling back to ${basePath}.`)
-	}
-
-	if (!mod?.default) {
-		throw new Error(`Cannot load agents from ${agentsModule}`)
-	}
-
-	return {
-		basePath,
-		factories: mod.default as Record<string, TestAgentFactory>,
-		bosunApi: parseBosunProjectApi(mod?.bosunApi ?? mod?.default?.bosunApi)
-	}
-}

package/src/backend/lib/get-root-path.ts

@@ -1,89 +0,0 @@
-import { glob } from 'glob'
-import path from 'node:path'
-import fs from 'node:fs'
-
-// TODO Drop this when all agents have bosun root
-const legacyPath = 'src/bosun/workflows.ts'
-
-async function resolveProjectPackageJsonPath(warnings: string[]): Promise<string> {
-	let projectRoot: string | undefined
-	if (process.env.BOSUN_NPX_RUN === 'true') {
-		if (fs.existsSync(path.join(process.cwd(), 'package.json'))) {
-			projectRoot = path.join(process.cwd(), 'package.json')
-		}
-	} else {
-		warnings.push(
-			'Run Bosun from your project folder.\n' +
-				' `projects` folder inside Bosun is deprecated, only first project is loaded!'
-		)
-		const projectFiles = await glob(`projects/*/package.json`, { absolute: true })
-		projectRoot = projectFiles[0]
-	}
-
-	if (!projectRoot) {
-		throw new Error('Cannot find project root directory or package.json in it.')
-	}
-
-	return projectRoot
-}
-
-export async function getProjectPackageJsonPath(): Promise<string> {
-	const warnings: string[] = []
-	const projectRoot = await resolveProjectPackageJsonPath(warnings)
-	if (warnings.length) {
-		printWarnings(warnings)
-	}
-	return projectRoot
-}
-
-export async function getProjectDir(): Promise<string> {
-	return path.dirname(await getProjectPackageJsonPath())
-}
-
-export async function getProjectPackageJson(): Promise<any> {
-	const pkgPath = await getProjectPackageJsonPath()
-	return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
-}
-
-/**
- * @returns full path to the file with agents factories
- */
-export async function getRootPath() {
-	const warnings: string[] = []
-	const projectRoot = await resolveProjectPackageJsonPath(warnings)
-	const pkg = JSON.parse(fs.readFileSync(projectRoot, 'utf-8'))
-	let bosunRoot: string | undefined = pkg?.bosun?.root
-	if (!bosunRoot) {
-		warnings.push(
-			'Specify `bosun.root` in your `package.json`.\n' +
-				`Running with legacy path: \`${legacyPath}\` which is deprecated!`
-		)
-		bosunRoot = legacyPath
-	}
-
-	if (warnings.length) {
-		printWarnings(warnings)
-	}
-	return path.resolve(path.dirname(projectRoot), bosunRoot)
-}
-
-function printWarnings(warnings: string[]) {
-	if (warnings.length === 0) return
-	const length = 100
-
-	const orange = '\x1b[91m' // ANSI bright red color
-	const reset = '\x1b[0m' // Reset color
-	const header = 'WARNING'
-
-	console.log(`${orange}┌─ ${header} ${'─'.repeat(length - header.length - 3)}┐${reset}`)
-
-	for (const warning of warnings) {
-		const lines = warning.split('\n')
-		for (let i = 0; i < lines.length; i++) {
-			const prefix = i === 0 ? '• ' : '  '
-			console.log(`${orange}│ ${prefix}${lines[i].padEnd(length - 4)} │${reset}`)
-		}
-	}
-
-	console.log(`${orange}└${'─'.repeat(length)}┘${reset}`)
-}

package/src/backend/lib/import-nonce.ts

@@ -1,10 +0,0 @@
-let importNonce = 0
-
-export function getImportNonce(): number {
-	return importNonce
-}
-
-export function bumpImportNonce(): number {
-	importNonce += 1
-	return importNonce
-}

package/src/backend/lib/middleware/cors.ts

@@ -1,14 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'http'
-
-export function cors(req: IncomingMessage, res: ServerResponse, next: () => void) {
-	res.setHeader('Access-Control-Allow-Origin', '*')
-	res.setHeader('Access-Control-Request-Method', '*')
-	res.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET, POST, PUT')
-	res.setHeader('Access-Control-Allow-Headers', '*')
-	if (req.method === 'OPTIONS') {
-		res.writeHead(200)
-		res.end()
-		return
-	}
-	next()
-}

package/src/backend/lib/project-api.ts

@@ -1,15 +0,0 @@
-import { getAgentFactories, type BosunProjectApiV1 } from './get-agent-factories'
-import { getImportNonce } from './import-nonce'
-import { getRootPath } from './get-root-path'
-
-export async function getProjectBosunApi(): Promise<BosunProjectApiV1 | null> {
-	const rootPath = await getRootPath()
-	const { bosunApi } = await getAgentFactories(rootPath, getImportNonce())
-	return bosunApi ?? null
-}
-
-export async function getProjectBasePath(): Promise<string> {
-	const rootPath = await getRootPath()
-	const { basePath } = await getAgentFactories(rootPath, getImportNonce())
-	return basePath
-}

package/src/backend/lib/project-data-dir.spec.ts

@@ -1,19 +0,0 @@
-import path from 'node:path'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { getProjectDataDir } from './project-data-dir'
-
-describe('getProjectDataDir', () => {
-	afterEach(() => {
-		vi.restoreAllMocks()
-	})
-
-	it('resolves runtime data paths from the cwd where bosun was launched', () => {
-		vi.spyOn(process, 'cwd').mockReturnValue('/tmp/example-project')
-
-		expect(getProjectDataDir()).toBe(path.resolve('/tmp/example-project', 'data'))
-		expect(getProjectDataDir('history', 'agent.json')).toBe(
-			path.resolve('/tmp/example-project', 'data', 'history', 'agent.json')
-		)
-	})
-})

package/src/backend/lib/project-data-dir.ts

@@ -1,9 +0,0 @@
-import path from 'node:path'
-
-/**
- * Mutable runtime data belongs to the project directory from which Bosun was launched,
- * not the Bosun install/repo directory.
- */
-export function getProjectDataDir(...segments: string[]): string {
-	return path.resolve(process.cwd(), 'data', ...segments)
-}

package/src/backend/lib/trpc-context.ts

@@ -1,8 +0,0 @@
-import type { CreateHTTPContextOptions } from '@trpc/server/adapters/standalone'
-import type { CreateWSSContextFnOptions } from '@trpc/server/adapters/ws'
-
-// context is what shared between trpc calls or how you put external stuff in it (e.g. DB connections)
-export function createContext(opts: CreateHTTPContextOptions | CreateWSSContextFnOptions) {
-	return {}
-}
-export type TrpcContext = Awaited<ReturnType<typeof createContext>>

package/src/backend/lib/voice-agent-lifecycle.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { sendCallStartMessage } from './voice-agent-lifecycle'
-
-describe('sendCallStartMessage', () => {
-	it('sends the initial message returned by a voice agent', async () => {
-		const sendMessage = vi.fn(async () => {})
-
-		await sendCallStartMessage(
-			{ initialMessage: 'Hello', initialSettings: { voice: 'test' } },
-			sendMessage
-		)
-
-		expect(sendMessage).toHaveBeenCalledOnce()
-		expect(sendMessage).toHaveBeenCalledWith('Hello')
-	})
-
-	it.each([
-		undefined,
-		null,
-		{},
-		{ initialMessage: 42 },
-		{ initialMessage: '' },
-		{ initialMessage: '  ' }
-	])('ignores a non-standard call-start result: %j', async (result) => {
-		const sendMessage = vi.fn(async () => {})
-
-		await sendCallStartMessage(result, sendMessage)
-
-		expect(sendMessage).not.toHaveBeenCalled()
-	})
-})

package/src/backend/lib/voice-agent-lifecycle.ts

@@ -1,16 +0,0 @@
-import type { Message } from '@recombine-ai/engine'
-
-export async function sendCallStartMessage(
-	result: unknown,
-	sendMessage: (message: string | Message) => Promise<void>
-): Promise<void> {
-	if (
-		typeof result === 'object' &&
-		result !== null &&
-		'initialMessage' in result &&
-		typeof result.initialMessage === 'string' &&
-		result.initialMessage.trim().length > 0
-	) {
-		await sendMessage(result.initialMessage)
-	}
-}

package/src/backend/region/router.ts

@@ -1,54 +0,0 @@
-import type { TRPCRootObject } from '@trpc/server/unstable-core-do-not-import'
-import { z } from 'zod'
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-
-import { bumpImportNonce } from '../lib/import-nonce'
-import { getProjectBosunApi } from '../lib/project-api'
-import { getProjectDir, getProjectPackageJson } from '../lib/get-root-path'
-import type { TrpcContext } from '../lib/trpc-context'
-
-const DEFAULT_REGION_CONFIG_PATH = 'src/region-config.json'
-
-async function resolveRegionConfigPath(): Promise<string> {
-	const projectDir = await getProjectDir()
-	const pkg = await getProjectPackageJson()
-	const configured = pkg?.bosun?.regionConfigPath
-	const rel = typeof configured === 'string' && configured.trim() ? configured.trim() : null
-	return path.resolve(projectDir, rel ?? DEFAULT_REGION_CONFIG_PATH)
-}
-
-async function fileExists(p: string): Promise<boolean> {
-	try {
-		await access(p)
-		return true
-	} catch {
-		return false
-	}
-}
-
-export function createRegionConfigRouter(t: TRPCRootObject<TrpcContext, any, any>) {
-	return t.router({
-		meta: t.procedure.input(z.object({ agent: z.string() })).query(async ({ input }) => {
-			const bosunApi = await getProjectBosunApi()
-			if (!bosunApi) return null
-			return bosunApi.getAgentMeta(input.agent)
-		}),
-		get: t.procedure.query(async () => {
-			const configPath = await resolveRegionConfigPath()
-			if (!(await fileExists(configPath))) {
-				throw new Error(`Cannot find region config at path '${configPath}'`)
-			}
-			return await readFile(configPath, 'utf-8')
-		}),
-		save: t.procedure.input(z.object({ text: z.string() })).mutation(async ({ input }) => {
-			const configPath = await resolveRegionConfigPath()
-			await mkdir(path.dirname(configPath), { recursive: true })
-			await writeFile(configPath, input.text, 'utf-8')
-
-			// Bump import nonce so subsequent imports of the project's module graph are cache-busted.
-			const importNonce = bumpImportNonce()
-			return { importNonce }
-		})
-	})
-}

package/src/backend/roleplay/agent-loader.ts

@@ -1,49 +0,0 @@
-import { createContext } from '@recombine-ai/engine'
-
-import { getAgentFactories } from '../lib/get-agent-factories'
-import { getRootPath } from '../lib/get-root-path'
-
-export const noop = () => void 0
-export const noopAsync = () => Promise.resolve()
-
-export async function loadAgentSteps(agentId: string) {
-	const { factory, basePath } = await getAgentFactory(agentId)
-	const ctx = createContext({})
-	const steps: any[] = []
-	const stepRegistry = {
-		addStep: (step: any) => {
-			steps.push(step)
-		},
-		getSteps: () => steps
-	}
-
-	await factory({
-		ctx,
-		getMessages: () => [],
-		logger: console,
-		scheduler: {
-			clearAllPendingActions: noopAsync,
-			registerAction: () => noopAsync
-		},
-		sendMessage: noopAsync,
-		stepRegistry,
-		stepTracer: {
-			addStepTrace: noop,
-			flush: noopAsync
-		},
-		config: {
-			enableTimers: false,
-			isTest: false
-		}
-	})
-
-	return { basePath, steps }
-}
-
-export async function getAgentFactory(agentId: string) {
-	const rootPath = await getRootPath()
-	const agentFactories = await getAgentFactories(rootPath)
-	const factory = agentFactories.factories[agentId]
-	if (!factory) throw new Error(`Cannot find agent ${agentId}`)
-	return { factory, basePath: agentFactories.basePath }
-}