Merge remote-tracking branch 'origin/email-imap'

src/servers/api/email/accounts.ts

@@ -0,0 +1,222 @@
+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);
+
+  // Check for stale syncing/queued accounts with no active job
+  const staleIds: number[] = [];
+  const hasActiveAccounts = accounts.some((a) => a.status === 'syncing' || a.status === 'queued');
+  let activeJobAccountIds = new Set<number>();
+
+  if (hasActiveAccounts) {
+    try {
+      const jobs = await sidecar.listJobs();
+      activeJobAccountIds = new Set(
+        jobs
+          .filter((j) => j.type === 'email-sync' && (j.status === 'queued' || j.status === 'running'))
+          .map((j) => (j.meta as Record<string, unknown> | undefined)?.emailAccountId as number)
+          .filter(Boolean),
+      );
+    } catch {
+      // Sidecar unavailable — all syncing/queued accounts are stale
+    }
+
+    for (const a of accounts) {
+      if ((a.status === 'syncing' || a.status === 'queued') && !activeJobAccountIds.has(a.id)) {
+        staleIds.push(a.id);
+      }
+    }
+
+    // Reset stale accounts in background
+    if (staleIds.length > 0) {
+      for (const id of staleIds) {
+        updateEmailAccountStatus(id, 'connected').catch(() => {});
+      }
+    }
+  }
+
+  return ctx.json(
+    accounts.map((a) => ({
+      id: a.id,
+      provider: a.provider,
+      email: a.email,
+      displayName: a.displayName,
+      enabled: a.enabled,
+      status: staleIds.includes(a.id) ? 'connected' : 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');
+
+  // Resolve auth before enqueueing
+  const authResult = await resolveAuth(user.id, account.authType, account.email, account.credentials as Record<string, unknown>);
+  if (!authResult.ok) throw BAD_REQUEST(authResult.error);
+
+  // 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,
+      userEmail: user.email,
+      account: {
+        id: account.id,
+        userId: account.userId,
+        email: account.email,
+        imapHost: account.imapHost,
+        imapPort: account.imapPort,
+        imapSecure: account.imapSecure,
+        provider: account.provider,
+        authType: account.authType,
+        credentials: account.credentials,
+      },
+      imapAuth: { user: account.email, ...authResult.auth },
+    },
+  });
+
+  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}` };
+}

src/servers/api/email/email.ts

@@ -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 {

src/servers/api/email/imap-validate.ts

@@ -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 };
+  }
+}

src/servers/api/integrations/google-auth.ts

@@ -0,0 +1,34 @@
+import { getServerIntegration } from 'officerdb';
+import { PermanentError } from '../../queue/types';
+
+type TokenRefreshResult = { accessToken: string; expiresAt: number };
+
+export async function refreshGoogleAccessToken(refreshToken: string): Promise<TokenRefreshResult> {
+  const serverGoogle = await getServerIntegration('google');
+  const serverConfig = serverGoogle?.config as Record<string, unknown> | undefined;
+  if (!serverConfig?.clientId || !serverConfig?.clientSecret) {
+    throw new PermanentError('Google OAuth not configured on server');
+  }
+
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      client_id: serverConfig.clientId as string,
+      client_secret: serverConfig.clientSecret as string,
+      refresh_token: refreshToken,
+      grant_type: 'refresh_token',
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Google token refresh failed: ${text}`);
+  }
+
+  const data = (await response.json()) as { access_token: string; expires_in: number };
+  return {
+    accessToken: data.access_token,
+    expiresAt: Date.now() + data.expires_in * 1000,
+  };
+}

src/servers/api/integrations/integrations.ts

@@ -259,11 +259,16 @@ export const googleCallbackHandler = async (ctx: any) => {
 
   const serverIntegration = await getServerIntegration('google');
 
+  // Merge with existing config to preserve fields like imapAppPassword
+  const existingIntegration = await getUserIntegration(dbUser.id, 'google');
+  const existingConfig = (existingIntegration?.config as Record<string, unknown>) ?? {};
+
   await upsertUserIntegration({
     userId: dbUser.id,
     provider: 'google',
     serverIntegrationId: serverIntegration?.id,
     config: {
+      ...existingConfig,
       accessToken: tokens.access_token,
       refreshToken: tokens.refresh_token,
       expiresAt: Date.now() + tokens.expires_in * 1000,