@recombine-ai/bosun 0.18.0 → 0.20.0

package/src/backend/roleplay/fs-persistence.ts

@@ -1,81 +0,0 @@
-import { type AgentState } from './agents'
-import fs from 'fs'
-import path from 'path'
-import { getProjectDataDir } from '../lib/project-data-dir'
-
-export interface StatePersistence {
-	load: (agentId: string) => Promise<AgentState[]>
-	save: (agentId: string, states: AgentState[]) => Promise<void>
-}
-
-export type Context = Record<string, any>
-
-export interface ContextPersistence {
-	load: (contextName: string) => Promise<Context>
-	save: (contextName: string, context: Context) => Promise<void>
-}
-
-export const fsStatePersistence: StatePersistence = {
-	load: async (agentId: string) => {
-		const filePath = getProjectDataDir('history', `${agentId}.json`)
-		return fsPersistence.load(filePath)
-	},
-	save: async (agentId: string, states: AgentState[]) => {
-		const filePath = getProjectDataDir('history', `${agentId}.json`)
-		return fsPersistence.save(filePath, states)
-	}
-}
-
-export const fsContextPersistence: ContextPersistence = {
-	load: async (contextName: string) => {
-		const filePath = getProjectDataDir('contexts', `${contextName}.json`)
-		return fsPersistence.load(filePath)
-	},
-	save: async (contextName: string, context: Context) => {
-		const filePath = getProjectDataDir('contexts', `${contextName}.json`)
-		return fsPersistence.save(filePath, context)
-	}
-}
-
-const fsPersistence = {
-	load: async (filePath: string) => {
-		try {
-			const data = String(await fs.promises.readFile(filePath))
-			return data ? JSON.parse(data) : ''
-		} catch (error) {
-			if ((error as any).code === 'ENOENT') {
-				await createFileIfNotExists(filePath)
-				return ''
-			}
-			console.error('error loading: ', filePath, String(await fs.promises.readFile(filePath)))
-			throw error
-		}
-	},
-	// TODO replace with JSONObject | JSONArray
-	save: async (filePath: string, toSave: Object) => {
-		await createFileIfNotExists(filePath)
-		await fs.promises.writeFile(filePath, JSON.stringify(toSave, null, 2))
-	}
-}
-
-/**
- * Ensures that a file exists by creating any necessary parent directories and the file itself
- * @param filePath Path to the file, may include nested directories
- */
-async function createFileIfNotExists(filePath: string) {
-	const directory = path.dirname(filePath)
-
-	try {
-		await fs.promises.access(directory)
-	} catch (error) {
-		// Directory doesn't exist, create it recursively
-		await fs.promises.mkdir(directory, { recursive: true })
-	}
-
-	try {
-		await fs.promises.access(filePath)
-	} catch (error) {
-		// File doesn't exist, create an empty file
-		await fs.promises.writeFile(filePath, '')
-	}
-}

package/src/backend/roleplay/logger.ts

@@ -1,30 +0,0 @@
-import { inspect } from 'util'
-import type { LogEntry } from '../../lib/ws-message'
-
-export function createLogger(sendMessage: (msg: LogEntry) => void) {
-	const enableConsole = !!process.env.PRINT_CONSOLE
-	return {
-		log: (...args: any[]) => {
-			if (enableConsole) console.log(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'INFO' })
-		},
-		debug: (...args: any[]) => {
-			if (enableConsole) console.debug(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'DEBUG' })
-		},
-		error: (...args: any[]) => {
-			if (enableConsole) console.error(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'ERROR' })
-		},
-		warn: (...args: any[]) => {
-			if (enableConsole) console.warn(...args)
-			sendMessage({ message: prettyArgs(args), severity: 'WARNING' })
-		}
-	}
-}
-
-function prettyArgs(args: any[]) {
-	return args
-		.map((arg) => (typeof arg === 'object' ? inspect(arg, { depth: null }) : arg))
-		.join(' ')
-}

package/src/backend/roleplay/message-dispatcher.ts

@@ -1,93 +0,0 @@
-import type {
-	DelayedActions,
-	LogEntry,
-	AgentPayload,
-	AgentSateHeader,
-	WsMessage
-} from '../../lib/ws-message'
-
-import {
-	type ApiCallTrace,
-	type StepTrace,
-	type ConversationalTrace
-} from '@recombine-ai/telescope'
-import { WebSocket } from 'ws'
-
-export class MessageDispatcher {
-	constructor(private ws: WebSocket) {}
-
-	private sendWsMessage(message: WsMessage) {
-		if (message.channel === 'app-events') {
-			console.log('<-- ', message.channel, message.event.type)
-		} else if (message.channel === 'step-trace') {
-			console.log('<-- ', message.channel, message.trace?.name)
-		} else if (message.channel === 'api-call-trace') {
-			console.log(
-				'<-- ',
-				message.channel,
-				`${message.trace?.operationName} (${message.trace?.method} ${message.trace?.path})`
-			)
-		} else if (message.channel === 'conversational-trace') {
-			console.log('<-- ', message.channel, `${message.trace?.eventName} (${message.trace?.role})`)
-		}
-		this.ws.send(JSON.stringify(message))
-	}
-
-	sendLog = async (message: LogEntry) => {
-		this.sendWsMessage({ channel: 'log', message })
-	}
-
-	sendTrace = async (trace: StepTrace) => {
-		this.sendWsMessage({ channel: 'step-trace', trace })
-	}
-
-	sendApiCallTrace = async (trace: ApiCallTrace) => {
-		this.sendWsMessage({ channel: 'api-call-trace', trace })
-	}
-
-	sendConversationalTrace = async (trace: ConversationalTrace) => {
-		this.sendWsMessage({ channel: 'conversational-trace', trace })
-	}
-
-	sendSchedule = async (actions: DelayedActions) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'delayed-actions-updated', actions }
-		})
-	}
-
-	sendAgentSelected = async (agent: AgentPayload) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'agent-selected', agent }
-		})
-	}
-
-	sendContext = async (context: Record<string, any>, promptContext: Record<string, any>) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'context-updated', context, promptContext }
-		})
-	}
-
-	sendPrompt = async (prompt: string) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'prompt-updated', prompt }
-		})
-	}
-
-	sendLoaded = async (agents: string[]) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'agents-loaded', agents }
-		})
-	}
-
-	sendUpdateStates = async (states: AgentSateHeader[]) => {
-		this.sendWsMessage({
-			channel: 'app-events',
-			event: { type: 'update-states', states }
-		})
-	}
-}

package/src/backend/roleplay/old-server.ts

@@ -1,96 +0,0 @@
-import { WebSocket } from 'ws'
-import type { WsMessage } from '../../lib/ws-message'
-import { createAgents } from './agents'
-import { fsContextPersistence, fsStatePersistence } from './fs-persistence'
-import { MessageDispatcher } from './message-dispatcher'
-
-export async function oldServer(ws: WebSocket) {
-	console.log('== Client connected ==')
-
-	const agents = createAgents(new MessageDispatcher(ws), fsStatePersistence, fsContextPersistence)
-
-	await agents.load()
-
-	// Queue websocket message handling so client-side multi-send sequences (e.g. select state -> send chat)
-	// are applied deterministically and don't race when handlers `await`.
-	let messageQueue = Promise.resolve()
-
-	ws.on('message', (event) => {
-		const raw = Array.isArray(event)
-			? Buffer.concat(event).toString()
-			: event instanceof ArrayBuffer
-				? Buffer.from(event).toString()
-				: event.toString()
-
-		messageQueue = messageQueue
-			.then(async () => {
-				let msg: WsMessage
-				try {
-					msg = JSON.parse(raw) as WsMessage
-				} catch (error) {
-					console.error('Error parsing websocket message', error)
-					return
-				}
-
-				// @ts-ignore
-				console.log('--> ', msg.channel, msg.event?.type || '')
-
-				switch (msg.channel) {
-					case 'app-events':
-						switch (msg.event.type) {
-							case 'select-agent':
-								await agents.select(
-									msg.event.agent,
-									msg.event.state,
-									msg.event.region,
-									msg.event.promptOverrides
-								)
-								break
-							case 'prompt-overrides-updated':
-								await agents.updatePromptOverrides(msg.event.prompts)
-								break
-							case 'reload-project':
-								await agents.reload()
-								break
-							case 'context-updated':
-								await agents.updateContext(msg.event.context)
-								break
-							case 'prompt-updated':
-								await agents.updatePrompt(msg.event.prompt)
-								break
-							case 'trigger-action':
-								await agents.triggerAction(msg.event.action)
-								break
-							case 'step-selected':
-								await agents.selectStep(msg.event.step)
-								break
-							case 'hangup':
-								await agents.hangup(msg.event.agentId, msg.event.region)
-								break
-
-							default:
-								console.error(`Unknown event type: ${msg.event.type}`)
-						}
-						break
-					case 'chat':
-						await agents.handleMessage(msg.message)
-						break
-					default:
-						console.error(`Unknown channel: ${msg.channel}`)
-				}
-			})
-			.catch((error) => {
-				console.error('Error handling message', error)
-				try {
-					ws.send(JSON.stringify({ channel: 'error', message: String(error) }))
-				} catch (sendError) {
-					console.error('Error sending websocket error', sendError)
-				}
-			})
-	})
-
-	ws.on('close', () => {
-		// TODO destroy agents here
-		console.log('=== client disconnected ===')
-	})
-}

package/src/backend/roleplay/prompt-edit-progress.ts

@@ -1,36 +0,0 @@
-export type PromptEditProgressPhase = 'thinking' | 'drafting' | 'reviewing'
-
-export type PromptEditProgress = {
-	id: string
-	phase: PromptEditProgressPhase
-	activity: number
-	summary: string
-	updatedAt: number
-}
-
-const progressById = new Map<string, PromptEditProgress>()
-const PROGRESS_TTL_MS = 15 * 60 * 1000
-
-export function updatePromptEditProgress(
-	id: string,
-	progress: Pick<PromptEditProgress, 'phase' | 'activity' | 'summary'>
-) {
-	removeExpiredProgress()
-	progressById.set(id, { id, ...progress, updatedAt: Date.now() })
-}
-
-export function getPromptEditProgress(id: string): PromptEditProgress | null {
-	removeExpiredProgress()
-	const progress = progressById.get(id)
-	return progress ? { ...progress } : null
-}
-
-export function deletePromptEditProgress(id: string) {
-	progressById.delete(id)
-}
-
-function removeExpiredProgress(now = Date.now()) {
-	for (const [id, progress] of progressById) {
-		if (progress.updatedAt + PROGRESS_TTL_MS <= now) progressById.delete(id)
-	}
-}

package/src/backend/roleplay/prompt-edit-proposals.ts

@@ -1,72 +0,0 @@
-import { randomUUID } from 'node:crypto'
-
-export type PromptEditProposal = {
-	id: string
-	agentId: string
-	step: string
-	originalPrompt: string
-	suggestedPrompt: string
-	createdAt: number
-}
-
-export interface PromptEditTestSourceGuard {
-	suiteKey: string
-	testId: string
-	allowedFingerprints: string[]
-}
-
-type StoredPromptEditProposal = PromptEditProposal & {
-	testSourceGuard?: PromptEditTestSourceGuard
-}
-
-const proposals = new Map<string, StoredPromptEditProposal>()
-const PROPOSAL_TTL_MS = 12 * 60 * 60 * 1000
-
-export function createPromptEditProposal(
-	proposal: Omit<PromptEditProposal, 'id' | 'createdAt'> & {
-		testSourceGuard?: PromptEditTestSourceGuard
-	}
-): PromptEditProposal {
-	removeExpiredPromptEditProposals()
-	const stored = { ...proposal, id: randomUUID(), createdAt: Date.now() }
-	proposals.set(stored.id, stored)
-	return publicProposal(stored)
-}
-
-export function getPromptEditProposal(id: string): PromptEditProposal | null {
-	removeExpiredPromptEditProposals()
-	const proposal = proposals.get(id)
-	return proposal ? publicProposal(proposal) : null
-}
-
-export function getPromptEditProposalForAcceptance(id: string): StoredPromptEditProposal | null {
-	removeExpiredPromptEditProposals()
-	const proposal = proposals.get(id)
-	return proposal
-		? {
-				...proposal,
-				testSourceGuard: proposal.testSourceGuard
-					? {
-							suiteKey: proposal.testSourceGuard.suiteKey,
-							testId: proposal.testSourceGuard.testId,
-							allowedFingerprints: [...proposal.testSourceGuard.allowedFingerprints]
-						}
-					: undefined
-			}
-		: null
-}
-
-export function deletePromptEditProposal(id: string): boolean {
-	return proposals.delete(id)
-}
-
-function removeExpiredPromptEditProposals(now = Date.now()) {
-	for (const [id, proposal] of proposals) {
-		if (proposal.createdAt + PROPOSAL_TTL_MS <= now) proposals.delete(id)
-	}
-}
-
-function publicProposal(proposal: StoredPromptEditProposal): PromptEditProposal {
-	const { testSourceGuard: _testSourceGuard, ...result } = proposal
-	return { ...result }
-}

package/src/backend/roleplay/prompt-file.ts

@@ -1,59 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { loadAgentSteps } from './agent-loader'
-
-export interface LockedPromptFile {
-	path: string
-	read: () => Promise<string>
-	write: (prompt: string) => Promise<void>
-}
-
-const promptMutationQueue = new Map<string, Promise<void>>()
-
-async function resolveEditablePrompt(agentId: string, stepName: string) {
-	const { basePath, steps } = await loadAgentSteps(agentId)
-	const targetStep = steps.find((step) => step?.name === stepName)
-	if (!targetStep || targetStep?.prompt?.type !== 'file') {
-		throw new Error(`Step '${stepName}' does not have an editable file prompt`)
-	}
-	return {
-		promptPath: path.resolve(basePath, targetStep.prompt.path),
-		readContent: () => targetStep.prompt.content() as Promise<string>
-	}
-}
-
-export async function readEditablePrompt(agentId: string, stepName: string): Promise<string> {
-	const { readContent } = await resolveEditablePrompt(agentId, stepName)
-	return readContent()
-}
-
-export async function withPromptFileLock<T>(
-	agentId: string,
-	stepName: string,
-	operation: (file: LockedPromptFile) => Promise<T>
-): Promise<T> {
-	const { promptPath } = await resolveEditablePrompt(agentId, stepName)
-	const canonicalPath = await fs.promises.realpath(promptPath)
-	const previous = promptMutationQueue.get(canonicalPath) ?? Promise.resolve()
-	let release!: () => void
-	const gate = new Promise<void>((resolve) => {
-		release = resolve
-	})
-	const queued = previous.catch(() => {}).then(() => gate)
-	promptMutationQueue.set(canonicalPath, queued)
-	await previous.catch(() => {})
-
-	try {
-		return await operation({
-			path: canonicalPath,
-			read: () => fs.promises.readFile(canonicalPath, 'utf-8'),
-			write: (prompt) => fs.promises.writeFile(canonicalPath, prompt, 'utf-8')
-		})
-	} finally {
-		release()
-		if (promptMutationQueue.get(canonicalPath) === queued) {
-			promptMutationQueue.delete(canonicalPath)
-		}
-	}
-}

package/src/backend/roleplay/router.spec.ts

@@ -1,75 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { initTRPC } from '@trpc/server'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-const mocks = vi.hoisted(() => ({
-	getAgentFactories: vi.fn()
-}))
-
-vi.mock('../lib/get-root-path', () => ({
-	getRootPath: async () => '/project/workflows.ts'
-}))
-
-vi.mock('../lib/get-agent-factories', () => ({
-	getAgentCatalog: vi.fn(),
-	getAgentFactories: mocks.getAgentFactories
-}))
-
-import type { TrpcContext } from '../lib/trpc-context'
-import { createPromptEditProposal, deletePromptEditProposal } from './prompt-edit-proposals'
-import { createRolePlayRouter } from './router'
-
-const temporaryDirectories: string[] = []
-const proposalIds: string[] = []
-
-afterEach(async () => {
-	for (const id of proposalIds.splice(0)) deletePromptEditProposal(id)
-	await Promise.all(
-		temporaryDirectories
-			.splice(0)
-			.map((directory) => rm(directory, { recursive: true, force: true }))
-	)
-	mocks.getAgentFactories.mockReset()
-})
-
-describe('acceptPromptEdit', () => {
-	it('does not overwrite a prompt that changed after the proposal was created', async () => {
-		const basePath = await mkdtemp(path.join(os.tmpdir(), 'bosun-prompt-edit-router-'))
-		temporaryDirectories.push(basePath)
-		const promptPath = path.join(basePath, 'prompt.md')
-		await writeFile(promptPath, 'newer prompt', 'utf8')
-
-		mocks.getAgentFactories.mockResolvedValue({
-			basePath,
-			factories: {
-				agent: async ({ stepRegistry }: any) => {
-					stepRegistry.addStep({
-						name: 'main',
-						prompt: {
-							type: 'file',
-							path: 'prompt.md',
-							content: () => readFile(promptPath, 'utf8')
-						}
-					})
-				}
-			}
-		})
-
-		const proposal = createPromptEditProposal({
-			agentId: 'agent',
-			step: 'main',
-			originalPrompt: 'original prompt',
-			suggestedPrompt: 'suggested prompt'
-		})
-		proposalIds.push(proposal.id)
-		const t = initTRPC.context<TrpcContext>().create()
-		const caller = createRolePlayRouter(t).createCaller({})
-
-		await expect(caller.acceptPromptEdit({ id: proposal.id })).rejects.toThrow(
-			'The prompt changed while this suggestion was open'
-		)
-		expect(await readFile(promptPath, 'utf8')).toBe('newer prompt')
-	})
-})