Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
feat(email-worker): inbound email handler with shared queries
Gener894d540a8414
diff --git a/src/email-worker/src/__mocks__/cf.ts b/src/email-worker/src/__mocks__/cf.tsnew file mode 100644index 000000000..827d87dbd--- /dev/null+++ b/src/email-worker/src/__mocks__/cf.ts@@ -0,0 +1,59 @@+import { vi } from "vitest"++// --- R2 Mock ---++export function createMockR2() {+ const put = vi.fn().mockResolvedValue(undefined)+ return { bucket: { put } as unknown as R2Bucket, put }+}++// --- Fetcher Mock (WEB_SERVICE) ---++export function createMockFetcher() {+ const fetch = vi.fn().mockResolvedValue(new Response("ok"))+ return { fetcher: { fetch } as unknown as Fetcher, fetch }+}++// --- ForwardableEmailMessage Mock ---++export interface MockMessageOpts {+ from: string+ to: string+ subject?: string | null+ body?: string+}++export function createMockMessage(opts: MockMessageOpts) {+ const headers = new Headers()+ if (opts.subject !== undefined && opts.subject !== null) {+ headers.set("subject", opts.subject)+ }++ const rawText = [+ `From: ${opts.from}`,+ `To: ${opts.to}`,+ `Subject: ${opts.subject ?? ""}`,+ "",+ opts.body ?? "",+ ].join("\r\n")++ const setReject = vi.fn()+ const forward = vi.fn().mockResolvedValue(undefined)+ const reply = vi.fn().mockResolvedValue(undefined)++ return {+ message: {+ from: opts.from,+ to: opts.to,+ headers,+ raw: new Response(rawText).body!,+ rawSize: rawText.length,+ setReject,+ forward,+ reply,+ } as unknown as ForwardableEmailMessage,+ setReject,+ forward,+ rawText,+ }+}diff --git a/src/email-worker/src/index.test.ts b/src/email-worker/src/index.test.tsnew file mode 100644index 000000000..fc71f9c2c--- /dev/null+++ b/src/email-worker/src/index.test.ts@@ -0,0 +1,266 @@+import { describe, it, expect, vi, beforeEach } from "vitest"+import { createMockR2, createMockFetcher, createMockMessage } from "./__mocks__/cf"++// Mock nanoid to return predictable IDs+let nanoidCounter = 0+vi.mock("nanoid", () => ({+ nanoid: () => `mock-id-${++nanoidCounter}`,+}))++// Mock @alook/shared at module level — the handler never touches Drizzle+const mockGetAgentByHandle = vi.fn()+const mockIsWhitelisted = vi.fn()+const mockGetUser = vi.fn()+const mockCreateDb = vi.fn(() => ({}))++vi.mock("@alook/shared", () => ({+ createDb: (...args: unknown[]) => mockCreateDb(...args),+ parseEmailHandle: (address: string) => {+ const domain = "@alook.ai"+ return address.endsWith(domain) ? address.slice(0, -domain.length) : ""+ },+ queries: {+ agent: { getAgentByHandle: (...args: unknown[]) => mockGetAgentByHandle(...args) },+ whitelist: { isWhitelisted: (...args: unknown[]) => mockIsWhitelisted(...args) },+ user: { getUser: (...args: unknown[]) => mockGetUser(...args) },+ },+}))++// Import handler after mocks are set up+import handler from "./index"++// Standard agent fixture+const AGENT = {+ id: "agent-1",+ workspaceId: "ws-1",+ ownerId: "user-1",+ emailHandle: "jarvis",+ forwardToEmail: "",+ name: "Jarvis",+ status: "idle",+}++function setup(overrides?: {+ agentOverrides?: Partial<typeof AGENT> | null+ isWhitelisted?: boolean+ userEmail?: string | null+ messageOpts?: Parameters<typeof createMockMessage>[0]+}) {+ const agent = overrides?.agentOverrides === null+ ? null+ : { ...AGENT, ...(overrides?.agentOverrides ?? {}) }++ mockGetAgentByHandle.mockResolvedValue(agent)+ mockIsWhitelisted.mockResolvedValue(overrides?.isWhitelisted ?? false)+ mockGetUser.mockResolvedValue(+ overrides?.userEmail !== undefined+ ? (overrides.userEmail ? { id: "user-1", email: overrides.userEmail } : null)+ : { id: "user-1", email: "[email protected]" }+ )++ const { bucket, put } = createMockR2()+ const { fetcher, fetch: wsFetch } = createMockFetcher()+ const { message, setReject, forward, rawText } = createMockMessage(+ overrides?.messageOpts ?? {+ from: "[email protected]",+ to: "[email protected]",+ subject: "Hello",+ body: "Test body",+ }+ )++ const env = { DB: {} as D1Database, EMAIL_BUCKET: bucket, WEB_SERVICE: fetcher }++ return { env, message, put, wsFetch, setReject, forward, rawText }+}++beforeEach(() => {+ nanoidCounter = 0+ vi.clearAllMocks()+})++// ─── Group 1: Agent resolution ───++describe("agent resolution", () => {+ it("rejects when no agent found for handle", async () => {+ const { env, message, setReject, put } = setup({ agentOverrides: null })++ await handler.email(message, env)++ expect(setReject).toHaveBeenCalledWith("No agent found for this address")+ expect(put).not.toHaveBeenCalled()+ })++ it("parses handle from alook.ai address and looks up agent", async () => {+ const { env, message } = setup({ isWhitelisted: true })++ await handler.email(message, env)++ expect(mockGetAgentByHandle).toHaveBeenCalledWith(expect.anything(), "jarvis")+ })++ it("rejects for non-alook domain (empty handle)", async () => {+ const { env, message, setReject } = setup({+ agentOverrides: null,+ messageOpts: { from: "[email protected]", to: "[email protected]", subject: "Hi" },+ })++ await handler.email(message, env)++ expect(setReject).toHaveBeenCalledWith("No agent found for this address")+ })+})++// ─── Group 2: R2 storage ───++describe("R2 storage", () => {+ it("stores raw email bytes at emails/{id}/raw with correct content-type", async () => {+ const { env, message, put } = setup({ isWhitelisted: true })++ await handler.email(message, env)++ expect(put).toHaveBeenCalledOnce()+ const [key, _body, opts] = put.mock.calls[0]+ expect(key).toBe("emails/mock-id-1/raw")+ expect(opts).toEqual({ httpMetadata: { contentType: "message/rfc822" } })+ })++ it("R2 put receives ArrayBuffer matching raw email content", async () => {+ const { env, message, put, rawText } = setup({ isWhitelisted: true })++ await handler.email(message, env)++ const storedBody = put.mock.calls[0][1] as ArrayBuffer+ const decoded = new TextDecoder().decode(storedBody)+ expect(decoded).toBe(rawText)+ })+})++// ─── Group 3: Whitelisted path ───++describe("whitelisted path", () => {+ it("notifies web service with isWhitelisted: true", async () => {+ const { env, message, wsFetch } = setup({ isWhitelisted: true })++ await handler.email(message, env)++ expect(wsFetch).toHaveBeenCalledOnce()+ const [url, init] = wsFetch.mock.calls[0]+ expect(url).toBe("http://internal/api/email/notify")+ expect(init.method).toBe("POST")+ const body = JSON.parse(init.body)+ expect(body.agentId).toBe("agent-1")+ expect(body.r2Key).toBe("emails/mock-id-1/raw")+ expect(body.from).toBe("[email protected]")+ expect(body.subject).toBe("Hello")+ expect(body.isWhitelisted).toBe(true)+ expect(body.forwarded).toBeUndefined()+ })++ it("defaults subject to empty string when header is missing", async () => {+ const { env, message, wsFetch } = setup({+ isWhitelisted: true,+ messageOpts: { from: "[email protected]", to: "[email protected]", subject: null },+ })++ await handler.email(message, env)++ const notifyBody = JSON.parse(wsFetch.mock.calls[0][1].body)+ expect(notifyBody.subject).toBe("")+ })++ it("does NOT call message.forward", async () => {+ const { env, message, forward } = setup({ isWhitelisted: true })++ await handler.email(message, env)++ expect(forward).not.toHaveBeenCalled()+ })+})++// ─── Group 4: Non-whitelisted path ───++describe("non-whitelisted path", () => {+ const strangerOpts = {+ messageOpts: { from: "[email protected]", to: "[email protected]", subject: "Spam" } as const,+ }++ it("notifies web service with isWhitelisted: false", async () => {+ const { env, message, wsFetch } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "[email protected]" },+ })++ await handler.email(message, env)++ expect(wsFetch).toHaveBeenCalledOnce()+ const body = JSON.parse(wsFetch.mock.calls[0][1].body)+ expect(body.isWhitelisted).toBe(false)+ expect(body.forwarded).toBe(true)+ })++ it("forwards email when forwardToEmail is set on agent", async () => {+ const { env, message, forward } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "[email protected]" },+ })++ await handler.email(message, env)++ expect(forward).toHaveBeenCalledWith("[email protected]")+ })++ it("notifies with forwarded: false when no forward address", async () => {+ const { env, message, wsFetch } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "", ownerId: null },+ })++ await handler.email(message, env)++ const body = JSON.parse(wsFetch.mock.calls[0][1].body)+ expect(body.isWhitelisted).toBe(false)+ expect(body.forwarded).toBe(false)+ })++ it("does NOT forward when forwardToEmail is empty", async () => {+ const { env, message, forward } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "", ownerId: null },+ })++ await handler.email(message, env)++ expect(forward).not.toHaveBeenCalled()+ })++ it("falls back to user email when forwardToEmail is empty", async () => {+ const { env, message, forward } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "", ownerId: "user-1" },+ userEmail: "[email protected]",+ })++ await handler.email(message, env)++ expect(mockGetUser).toHaveBeenCalledWith(expect.anything(), "user-1")+ expect(forward).toHaveBeenCalledWith("[email protected]")+ })++ it("does not call getUser when forwardToEmail is set", async () => {+ const { env, message } = setup({+ ...strangerOpts,+ isWhitelisted: false,+ agentOverrides: { forwardToEmail: "[email protected]" },+ })++ await handler.email(message, env)++ expect(mockGetUser).not.toHaveBeenCalled()+ })+})diff --git a/src/email-worker/src/index.ts b/src/email-worker/src/index.tsindex 54a3333e3..71f078802 100644--- a/src/email-worker/src/index.ts+++ b/src/email-worker/src/index.ts@@ -1,4 +1,122 @@+import { nanoid } from "nanoid"+import { createDb, queries, parseEmailHandle } from "@alook/shared"++interface EmailEnv {+ DB: D1Database+ EMAIL_BUCKET: R2Bucket+ WEB_SERVICE: Fetcher+}+export default {- async email() {},- async fetch() { return new Response("email-worker") },+ async fetch(request: Request, env: EmailEnv): Promise<Response> {+ const url = new URL(request.url)+ if (url.pathname !== "/simulate" || request.method !== "POST") {+ return new Response("POST /simulate to send a test email", { status: 404 })+ }++ const body = await request.json() as { from: string; to: string; subject?: string; body?: string }+ if (!body.from || !body.to) {+ return new Response("from and to required", { status: 400 })+ }++ const raw = [+ `From: ${body.from}`,+ `To: ${body.to}`,+ `Subject: ${body.subject ?? "(test)"}`,+ `Date: ${new Date().toUTCString()}`,+ "",+ body.body ?? "",+ ].join("\r\n")++ const rawStream = new ReadableStream({+ start(controller) {+ controller.enqueue(new TextEncoder().encode(raw))+ controller.close()+ },+ })++ const headers = new Headers()+ headers.set("subject", body.subject ?? "(test)")++ const fakeMessage = {+ from: body.from,+ to: body.to,+ raw: rawStream,+ headers,+ setReject(reason: string) { console.log("Rejected:", reason) },+ forward(_to: string) { console.log("Forwarded to:", _to); return Promise.resolve() },+ } as unknown as ForwardableEmailMessage++ try {+ await this.email(fakeMessage, env)+ return Response.json({ ok: true })+ } catch (e) {+ const msg = e instanceof Error ? e.message : String(e)+ console.error("Simulate error:", msg)+ return Response.json({ error: msg }, { status: 500 })+ }+ },++ async email(message: ForwardableEmailMessage, env: EmailEnv): Promise<void> {+ const db = createDb(env.DB)+ const handle = parseEmailHandle(message.to)++ const agent = await queries.agent.getAgentByHandle(db, handle)+ if (!agent) {+ message.setReject("No agent found for this address")+ return+ }++ const whitelisted = await queries.whitelist.isWhitelisted(db, agent.id, message.from)++ const rawBytes = await new Response(message.raw).arrayBuffer()+ const r2Id = nanoid()+ const r2Key = `emails/${r2Id}/raw`+ await env.EMAIL_BUCKET.put(r2Key, rawBytes, {+ httpMetadata: { contentType: "message/rfc822" },+ })++ const subject = message.headers.get("subject") ?? ""++ if (whitelisted) {+ await env.WEB_SERVICE.fetch("http://internal/api/email/notify", {+ method: "POST",+ headers: { "Content-Type": "application/json" },+ body: JSON.stringify({+ agentId: agent.id,+ r2Key,+ from: message.from,+ subject,+ isWhitelisted: true,+ }),+ })+ } else {+ const forwardToEmail = agent.forwardToEmail ?? ""+ let forwardAddress = forwardToEmail++ if (!forwardAddress) {+ const agentUser = agent.ownerId ? await queries.user.getUser(db, agent.ownerId) : null+ forwardAddress = agentUser?.email ?? ""+ }++ const forwarded = !!forwardAddress++ await env.WEB_SERVICE.fetch("http://internal/api/email/notify", {+ method: "POST",+ headers: { "Content-Type": "application/json" },+ body: JSON.stringify({+ agentId: agent.id,+ r2Key,+ from: message.from,+ subject,+ isWhitelisted: false,+ forwarded,+ }),+ })++ if (forwardAddress) {+ await message.forward(forwardAddress)+ }+ }+ },}