Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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 ?? {
+ 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.ts
index 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)
+ }
+ }
+ },
}