pastilhasandClaude Opus 5
af56eb36ff
Email was the one sidecar built inside out. The platform held ~1,800 lines — the per-account
SQLite store, all 14 HTTP routes, account CRUD, resync, IMAP validation — while the 314-line
sidecar was a scheduler that reached BACK into the platform to do anything
(`import { performResync } from '../../api/email/resync'`).
The sidecar now serves its own HTTP listener and announces `email:server`, and
/api/email/* on the platform is createSidecarProxy like every other one: 1,801 lines down
to 22, with no mail knowledge left in it — not a message, not a folder, not a credential.
The routes moved verbatim, Hono and all. http.ts only reconstructs what the platform's
middleware used to provide: `user` on the context, from the X-Officer-User header the proxy
injects (trusted because this server binds loopback), and an error handler that turns
custom-errors into status codes.
The /email/events SSE stream went with them, which removes a whole round trip: the IDLE
watcher used to send `email:new` over the registration socket so the platform could push to
its SSE clients. Those clients are here now, so it calls broadcastEmailNew in-process and
`email:new` is gone from the wire protocol.
DELIBERATELY NOT DONE YET, and left backwards on purpose rather than half-moved:
- The two sync handlers (email-sync 381 lines, gmail-sync 712) still run in the platform's
queue and now import the store from its new home — a platform → sidecar import, which is
the wrong direction and is temporary. Moving them is option (A) from the plan: the sidecar
schedules its own syncs, independent of the platform Jobs list.
- accounts.ts still imports queue/init to enqueue a sync and to report sync status, and
index.ts still carries the queue-over-WS shim that inversion needs.
- The three channel handlers still open the mail store directly rather than asking over HTTP.
Two things worth knowing while testing: a from-scratch sync holds a proxied request open
well past the 60s idle default, hence timeoutSeconds on the proxy; and `gmail-sync` is
hardcoded in all three channel handlers even though the only account is provider=gmail with
auth_type=password, which routes to IMAP — so "sync emails" from a chat channel is
almost certainly already broken, and folds into the next stage.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
48 lines
1.3 KiB
TypeScript
48 lines
1.3 KiB
TypeScript
import { getAllSyncedAccounts, getUserById } from 'officerdb';
|
|
import { performResync } from './resync';
|
|
|
|
const INTERVAL_MS = 10 * 60 * 1000; // 10 minutes
|
|
|
|
let timer: ReturnType<typeof setInterval> | null = null;
|
|
|
|
async function tick() {
|
|
try {
|
|
const accounts = await getAllSyncedAccounts();
|
|
if (accounts.length === 0) return;
|
|
|
|
for (const account of accounts) {
|
|
const user = await getUserById(account.userId);
|
|
if (!user) continue;
|
|
|
|
try {
|
|
console.log(`[email-cron] Resyncing ${account.email}`);
|
|
const result = await performResync({ accountId: account.id, userEmail: user.email, userId: user.id });
|
|
if (result.saved > 0) {
|
|
console.log(`[email-cron] ${account.email}: ${result.saved} new emails`);
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
`[email-cron] Failed to resync ${account.email}:`,
|
|
err instanceof Error ? err.message : err,
|
|
);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error('[email-cron] Error:', err instanceof Error ? err.message : err);
|
|
}
|
|
}
|
|
|
|
export function initEmailCron() {
|
|
if (timer) return;
|
|
console.log(`[email-cron] Starting email sync cron (every ${INTERVAL_MS / 60_000} min)`);
|
|
timer = setInterval(tick, INTERVAL_MS);
|
|
setTimeout(tick, 30_000);
|
|
}
|
|
|
|
export function stopEmailCron() {
|
|
if (timer) {
|
|
clearInterval(timer);
|
|
timer = null;
|
|
}
|
|
}
|