Skip to content

armgit / crm

Public Imported from GitHub
0

Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.

TypeScript
5.8 KB
Raw Blame
import { db } from "@crm/db";
import { PRIORITY } from "@crm/db/agent-tasks";
import { runVisibleLane } from "../../agent/lib/dispatch";
import {
	reasonOf,
	removeAgent,
	removeAgentsNamed,
	removeEventRuns,
} from "./e2e-agents";
import { E2E } from "./e2e-config";

const results: Array<{ name: string; ok: boolean; detail: string }> = [];

function record(name: string, ok: boolean, detail: string) {
	results.push({ name, ok, detail });
	console.log(`${ok ? "PASS" : "FAIL"}  ${name} — ${detail}`);
}

async function seedAgent() {
	const owner = await db.user.findFirstOrThrow({ select: { id: true } });
	const agent = await db.agentDefinition.create({
		data: {
			name: `${E2E.dispatch.agentPrefix} ${Date.now()}`,
			description: "Seeded by the dispatch E2E. Safe to delete.",
			status: "LIVE",
			createdById: owner.id,
		},
		select: { id: true },
	});
	const version = await db.agentVersion.create({
		data: {
			agentId: agent.id,
			number: 1,
			status: "DEPLOYED",
			instructions: "Dispatch test agent. Does nothing.",
			modelId: "test/model",
			sandboxPolicy: {},
			createdById: owner.id,
			manifest: {
				description: "dispatch test",
				triggers: [
					{
						type: "EVENT",
						name: "Deal created",
						summary: "Fires on deal creation",
						config: { event: "deal.created" },
					},
				],
				dataScope: { mode: "WORKSPACE", summary: "Workspace", resources: [] },
				actions: [
					{ type: "run.summary", provider: "crm", summary: "Log the result" },
				],
			},
		},
		select: { id: true },
	});
	await db.agentDefinition.update({
		where: { id: agent.id },
		data: { currentVersionId: version.id },
	});
	await db.agentTrigger.create({
		data: {
			agentId: agent.id,
			versionId: version.id,
			type: "EVENT",
			name: "Deal created",
			config: { event: "deal.created" },
			enabled: true,
			createdById: owner.id,
		},
	});
	return { agentId: agent.id };
}

async function seedDeal() {
	const stamp = Date.now();
	const company = await db.company.create({
		data: {
			name: `${E2E.dispatch.companyPrefix} ${stamp}`,
			domain: `${E2E.dispatch.domainPrefix}${stamp}${E2E.dispatch.domainSuffix}`,
		},
		select: { id: true },
	});
	const owner = await db.user.findFirstOrThrow({ select: { id: true } });
	return db.deal.create({
		data: {
			name: `E2E Deal ${Date.now()}`,
			companyId: company.id,
			ownerId: owner.id,
			stage: "DEMO_BOOKED",
			stageChangedAt: new Date(),
		},
		select: { id: true, companyId: true },
	});
}

async function sweepLeftovers() {
	for (const name of await removeAgentsNamed(E2E.dispatch.agentPrefix)) {
		console.log(`  removed leftover ${name}`);
	}

	const stale = await db.company.findMany({
		where: {
			domain: {
				startsWith: E2E.dispatch.domainPrefix,
				endsWith: E2E.dispatch.domainSuffix,
			},
			name: { startsWith: E2E.dispatch.companyPrefix },
		},
		select: { id: true, name: true },
	});

	for (const company of stale) {
		const deals = await db.deal.findMany({
			where: { companyId: company.id },
			select: { id: true },
		});
		await db.agentTask.deleteMany({
			where: { dealId: { in: deals.map((deal) => deal.id) } },
		});
		await db.deal.deleteMany({ where: { companyId: company.id } });
		await db.company.delete({ where: { id: company.id } });
		console.log(`  removed leftover ${company.name}`);
	}
}

async function cleanUp(
	agentId: string | null,
	companyId: string | null,
	dealId: string | null,
	taskId: string | null,
) {
	await removeEventRuns(taskId ? [taskId] : []);
	if (agentId) await removeAgent(agentId);
	if (dealId) await db.agentTask.deleteMany({ where: { dealId } });
	if (!companyId) return;
	await db.deal.deleteMany({ where: { companyId } });
	await db.company.delete({ where: { id: companyId } });
}

async function main() {
	await sweepLeftovers();

	let agentId: string | null = null;
	let companyId: string | null = null;
	let dealId: string | null = null;
	let taskId: string | null = null;

	try {
		const seededAgent = await seedAgent();
		agentId = seededAgent.agentId;
		const deal = await seedDeal();
		companyId = deal.companyId;
		dealId = deal.id;
		const task = await db.agentTask.create({
			data: {
				dealId: deal.id,
				kind: "agent-event",
				reason: "deal.created",
				payload: {
					type: "deal.created",
					record: { kind: "deal", id: deal.id },
					occurredAt: new Date().toISOString(),
					data: { companyId: deal.companyId, stage: "DEMO_BOOKED" },
				},
				priority: PRIORITY.event,
				budget: 1,
				dueAt: new Date(),
			},
			select: { id: true },
		});
		taskId = task.id;

		const before = await db.agentRun.count();
		const handled = await runVisibleLane();
		const after = await db.agentRun.count();

		record(
			"drain claims a queued event",
			handled > 0,
			`visible lane handled ${handled} task(s)`,
		);

		const settled = await db.agentTask.findUnique({
			where: { id: task.id },
			select: { finishedAt: true, outcome: true },
		});
		record(
			"drain settles the task",
			Boolean(settled?.finishedAt),
			settled?.outcome ?? "not settled",
		);

		const live = await db.agentDefinition.count({ where: { status: "LIVE" } });
		record(
			"event matched against live agents",
			after > before,
			`${after - before} run(s) queued from ${live} live agent(s)`,
		);

		const stuck = await db.agentTask.count({
			where: { kind: "agent-event", finishedAt: null },
		});
		record("no agent-event backlog", stuck === 0, `${stuck} unclaimed`);
	} finally {
		const failure = await cleanUp(agentId, companyId, dealId, taskId).then(
			() => null,
			(cause: unknown) => reasonOf(cause),
		);
		record(
			"cleanup leaves no seeded rows",
			failure === null,
			failure ?? "agent, run, task, deal and company removed",
		);
	}

	const failed = results.filter((row) => !row.ok).length;
	console.log(
		failed === 0
			? `\nAll ${results.length} dispatch checks passed.`
			: `\n${failed} of ${results.length} dispatch checks failed.`,
	);
	process.exit(failed === 0 ? 0 : 1);
}

await main();