wip: email sync via imap with status tracking and auto cron

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-06 04:57:30 +00:00
parent 5925ac49a1
commit 170bd6d41b
20 changed files with 1929 additions and 373 deletions
@@ -0,0 +1,171 @@
+import { createRouter } from '../../create-router';
+import { BAD_REQUEST, NOT_FOUND } from '../../custom-errors';
+import {
+  getEmailAccounts,
+  getEmailAccount,
+  createEmailAccount,
+  deleteEmailAccount,
+  getUserIntegration,
+  updateEmailAccountStatus,
+} from 'officerdb';
+import { validateImapConnection } from './imap-validate';
+import * as sidecar from '../../sidecar-client';
+
+type CreateAccountBody = {
+  provider: string;
+  email: string;
+  displayName?: string;
+  imapHost: string;
+  imapPort: number;
+  imapSecure: boolean;
+  authType: string;
+  credentials: Record<string, unknown>;
+};
+
+type ValidateBody = {
+  imapHost: string;
+  imapPort: number;
+  imapSecure: boolean;
+  authType: string;
+  email: string;
+  credentials: Record<string, unknown>;
+};
+
+export const accountsRouter = createRouter();
+
+accountsRouter.get('/', async (ctx) => {
+  const user = ctx.get('user');
+  const accounts = await getEmailAccounts(user.id);
+  return ctx.json(
+    accounts.map((a) => ({
+      id: a.id,
+      provider: a.provider,
+      email: a.email,
+      displayName: a.displayName,
+      enabled: a.enabled,
+      status: a.status,
+      createdAt: a.createdAt,
+    })),
+  );
+});
+
+accountsRouter.post('/', async (ctx) => {
+  const user = ctx.get('user');
+  const body = ctx.get('body') as CreateAccountBody;
+
+  if (!body.provider || !body.email || !body.imapHost || !body.imapPort || !body.authType) {
+    throw BAD_REQUEST('Missing required fields');
+  }
+
+  const authResult = await resolveAuth(user.id, body.authType, body.email, body.credentials);
+  if (!authResult.ok) throw BAD_REQUEST(authResult.error);
+
+  const validation = await validateImapConnection({
+    host: body.imapHost,
+    port: body.imapPort,
+    secure: body.imapSecure,
+    user: body.email,
+    ...authResult.auth,
+  });
+
+  if (!validation.ok) throw BAD_REQUEST(`IMAP connection failed: ${validation.error}`);
+
+  const account = await createEmailAccount({
+    userId: user.id,
+    provider: body.provider,
+    email: body.email,
+    displayName: body.displayName,
+    imapHost: body.imapHost,
+    imapPort: body.imapPort,
+    imapSecure: body.imapSecure,
+    authType: body.authType,
+    credentials: body.credentials,
+  });
+
+  return ctx.json({ id: account.id, provider: account.provider, email: account.email }, 201);
+});
+
+accountsRouter.delete('/:id', async (ctx) => {
+  const user = ctx.get('user');
+  const id = Number(ctx.req.param('id'));
+  const deleted = await deleteEmailAccount(id, user.id);
+  if (!deleted) throw NOT_FOUND('Account not found');
+  return ctx.json({ ok: true });
+});
+
+accountsRouter.post('/:id/sync', async (ctx) => {
+  const user = ctx.get('user');
+  const id = Number(ctx.req.param('id'));
+
+  const account = await getEmailAccount(id);
+  if (!account || account.userId !== user.id) throw NOT_FOUND('Account not found');
+
+  if (account.status === 'queued') throw BAD_REQUEST('Sync is already queued');
+  if (account.status === 'syncing') throw BAD_REQUEST('Account is already syncing');
+  if (account.status === 'synced') throw BAD_REQUEST('Account is already synced — incremental syncs run automatically');
+
+  // Set status immediately so the UI reflects the queued state
+  await updateEmailAccountStatus(id, 'queued');
+
+  const job = await sidecar.enqueueJob({
+    lane: 'email',
+    type: 'email-sync',
+    userId: user.email,
+    meta: { emailAccountId: id },
+  });
+
+  return ctx.json({ ok: true, jobId: job.id }, 201);
+});
+
+accountsRouter.post('/validate', async (ctx) => {
+  const user = ctx.get('user');
+  const body = ctx.get('body') as ValidateBody;
+
+  if (!body.imapHost || !body.imapPort || !body.authType || !body.email) {
+    throw BAD_REQUEST('Missing required fields');
+  }
+
+  const authResult = await resolveAuth(user.id, body.authType, body.email, body.credentials);
+  if (!authResult.ok) return ctx.json({ ok: false, error: authResult.error });
+
+  const result = await validateImapConnection({
+    host: body.imapHost,
+    port: body.imapPort,
+    secure: body.imapSecure,
+    user: body.email,
+    ...authResult.auth,
+  });
+
+  return ctx.json(result);
+});
+
+type AuthResult = { ok: true; auth: { pass?: string; accessToken?: string } } | { ok: false; error: string };
+
+async function resolveAuth(
+  userId: number,
+  authType: string,
+  email: string,
+  credentials: Record<string, unknown>,
+): Promise<AuthResult> {
+  if (authType === 'oauth') {
+    const integrationId = credentials.userIntegrationId as number | undefined;
+    if (!integrationId) return { ok: false, error: 'Missing userIntegrationId for OAuth' };
+
+    const integration = await getUserIntegration(userId, 'google');
+    if (!integration) return { ok: false, error: 'Google integration not found' };
+
+    const config = integration.config as Record<string, unknown>;
+    const accessToken = config.accessToken as string | undefined;
+    if (!accessToken) return { ok: false, error: 'No access token available — reconnect Google account' };
+
+    return { ok: true, auth: { accessToken } };
+  }
+
+  if (authType === 'password') {
+    const pass = credentials.password as string | undefined;
+    if (!pass) return { ok: false, error: 'Missing password' };
+    return { ok: true, auth: { pass } };
+  }
+
+  return { ok: false, error: `Unknown auth type: ${authType}` };
+}
@@ -4,9 +4,12 @@ import type { EmailMessage } from 'types';
 import { createRouter } from '../../create-router';
 import { DATA_PATH } from '@@/data-path';
 import { openEmailDb, rowToSummary, getSyncMeta } from './email-db';
+import { accountsRouter } from './accounts';

 export const emailRouter = createRouter();

+emailRouter.route('/accounts', accountsRouter);
+
 emailRouter.get('/messages', async (ctx) => {
  const email = ctx.get('user').email;
  const page = Number(ctx.req.query('page') ?? '1');
@@ -18,7 +21,9 @@ emailRouter.get('/messages', async (ctx) => {

  const db = openEmailDb(email);
  try {
-    const rows = db.query(`SELECT * FROM emails WHERE ${folderWhere} ORDER BY date DESC LIMIT ? OFFSET ?`).all(limit, offset) as Record<string, unknown>[];
+    const rows = db
+      .query(`SELECT * FROM emails WHERE ${folderWhere} ORDER BY date DESC LIMIT ? OFFSET ?`)
+      .all(limit, offset) as Record<string, unknown>[];
    const countRow = db.query(`SELECT COUNT(*) as total FROM emails WHERE ${folderWhere}`).get() as { total: number };
    const messages = rows.map(rowToSummary);
    return ctx.json({ messages, total: countRow.total });
@@ -36,11 +41,11 @@ emailRouter.get('/messages/:id', async (ctx) => {
    const row = db.query('SELECT * FROM emails WHERE id = ? AND deleted = 0').get(id) as Record<string, unknown> | null;
    if (!row) return ctx.text('Not found', 404);

-    const attachmentRows = db.query('SELECT * FROM attachments WHERE email_id = ? ORDER BY idx').all(id) as Array<Record<string, unknown>>;
+    const attachmentRows = db.query('SELECT * FROM attachments WHERE email_id = ? ORDER BY idx').all(id) as Array<
+      Record<string, unknown>
+    >;

-    const from = row.from_name
-      ? `${row.from_name} <${row.from_address}>`
-      : (row.from_address as string);
+    const from = row.from_name ? `${row.from_name} <${row.from_address}>` : (row.from_address as string);

    const message: EmailMessage = {
      id: row.id as string,
@@ -75,7 +80,10 @@ emailRouter.post('/messages/:id/attachments/:index/extract', async (ctx) => {

  const db = openEmailDb(email);
  try {
-    const row = db.query('SELECT filename, content FROM attachments WHERE email_id = ? AND idx = ?').get(id, index) as { filename: string; content: string | null } | null;
+    const row = db.query('SELECT filename, content FROM attachments WHERE email_id = ? AND idx = ?').get(id, index) as {
+      filename: string;
+      content: string | null;
+    } | null;
    if (!row || !row.content) return ctx.text('Attachment not found', 404);

    const fileName = row.filename ?? 'unknown';
@@ -144,9 +152,18 @@ emailRouter.get('/stats', async (ctx) => {

  const db = openEmailDb(email);
  try {
-    const total = (db.query(`SELECT COUNT(*) as count FROM emails WHERE ${folderWhere}`).get() as { count: number }).count;
-    const byDomain = db.query(`SELECT from_domain, COUNT(*) as count FROM emails WHERE ${folderWhere} GROUP BY from_domain ORDER BY count DESC LIMIT 20`).all() as Array<{ from_domain: string; count: number }>;
-    const bySender = db.query(`SELECT from_address, from_name, COUNT(*) as count FROM emails WHERE ${folderWhere} GROUP BY from_address ORDER BY count DESC LIMIT 20`).all() as Array<{ from_address: string; from_name: string; count: number }>;
+    const total = (db.query(`SELECT COUNT(*) as count FROM emails WHERE ${folderWhere}`).get() as { count: number })
+      .count;
+    const byDomain = db
+      .query(
+        `SELECT from_domain, COUNT(*) as count FROM emails WHERE ${folderWhere} GROUP BY from_domain ORDER BY count DESC LIMIT 20`,
+      )
+      .all() as Array<{ from_domain: string; count: number }>;
+    const bySender = db
+      .query(
+        `SELECT from_address, from_name, COUNT(*) as count FROM emails WHERE ${folderWhere} GROUP BY from_address ORDER BY count DESC LIMIT 20`,
+      )
+      .all() as Array<{ from_address: string; from_name: string; count: number }>;

    return ctx.json({ total, byDomain, bySender });
  } finally {
@@ -159,7 +176,9 @@ emailRouter.get('/labels', async (ctx) => {

  const db = openEmailDb(email);
  try {
-    const rows = db.query('SELECT labels FROM emails WHERE deleted = 0 AND labels IS NOT NULL').all() as Array<{ labels: string }>;
+    const rows = db.query('SELECT labels FROM emails WHERE deleted = 0 AND labels IS NOT NULL').all() as Array<{
+      labels: string;
+    }>;

    const counts = new Map<string, number>();
    for (const row of rows) {
@@ -169,9 +188,7 @@ emailRouter.get('/labels', async (ctx) => {
      }
    }

-    const labels = [...counts.entries()]
-      .map(([label, count]) => ({ label, count }))
-      .sort((a, b) => b.count - a.count);
+    const labels = [...counts.entries()].map(([label, count]) => ({ label, count })).sort((a, b) => b.count - a.count);

    return ctx.json({ labels });
  } finally {
@@ -0,0 +1,54 @@
+type ValidateImapParams = {
+  host: string;
+  port: number;
+  secure: boolean;
+  user: string;
+  pass?: string;
+  accessToken?: string;
+};
+
+type ValidateImapResult = { ok: true; folderCount: number } | { ok: false; error: string };
+
+export async function validateImapConnection(params: ValidateImapParams): Promise<ValidateImapResult> {
+  const { ImapFlow } = await import('imapflow');
+
+  const auth: { user: string; pass?: string; accessToken?: string } = { user: params.user };
+  if (params.accessToken) {
+    auth.accessToken = params.accessToken;
+  } else if (params.pass) {
+    auth.pass = params.pass;
+  } else {
+    return { ok: false, error: 'No authentication credentials provided' };
+  }
+
+  const client = new ImapFlow({
+    host: params.host,
+    port: params.port,
+    secure: params.secure,
+    auth,
+    logger: false,
+    greetingTimeout: 60_000,
+    socketTimeout: 60_000,
+  });
+
+  try {
+    const result = await Promise.race([
+      (async () => {
+        await client.connect();
+        const folders = await client.list();
+        await client.logout();
+        return { ok: true as const, folderCount: folders.length };
+      })(),
+      new Promise<ValidateImapResult>((_, reject) =>
+        setTimeout(() => reject(new Error('Connection timed out')), 90_000),
+      ),
+    ]);
+    return result;
+  } catch (err) {
+    try {
+      client.close();
+    } catch {}
+    const message = err instanceof Error ? err.message : 'Connection failed';
+    return { ok: false, error: message };
+  }
+}