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>
89 lines
3.0 KiB
TypeScript
89 lines
3.0 KiB
TypeScript
import { ImapFlow } from 'imapflow';
|
|
import { getUserByEmail, getUserIntegration, getServerIntegration } from 'officerdb';
|
|
import { openEmailDb, setSyncMeta } from '../src/servers/sidecar/email/store';
|
|
|
|
const userEmail = process.argv[2];
|
|
if (!userEmail) {
|
|
console.error('Usage: bun run scripts/seed-imap-uids.ts <email>');
|
|
process.exit(1);
|
|
}
|
|
|
|
// ── Load credentials ──
|
|
|
|
const dbUser = await getUserByEmail(userEmail);
|
|
if (!dbUser) throw new Error('User not found');
|
|
|
|
const userGoogle = await getUserIntegration(dbUser.id, 'google');
|
|
const config = userGoogle?.config as Record<string, unknown> | undefined;
|
|
if (!config?.accessToken) throw new Error('No OAuth tokens found');
|
|
|
|
// Refresh token if needed
|
|
let accessToken = config.accessToken as string;
|
|
const expiresAt = config.expiresAt as number | undefined;
|
|
if (!expiresAt || expiresAt < Date.now() + 60_000) {
|
|
console.log('Refreshing expired token...');
|
|
const serverGoogle = await getServerIntegration('google');
|
|
const serverConfig = serverGoogle?.config as Record<string, unknown>;
|
|
const res = 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: config.refreshToken as string,
|
|
grant_type: 'refresh_token',
|
|
}),
|
|
});
|
|
if (!res.ok) throw new Error(`Token refresh failed: ${await res.text()}`);
|
|
const data = (await res.json()) as { access_token: string };
|
|
accessToken = data.access_token;
|
|
}
|
|
|
|
// ── Connect IMAP ──
|
|
|
|
const client = new ImapFlow({
|
|
host: 'imap.gmail.com',
|
|
port: 993,
|
|
secure: true,
|
|
auth: { user: config.email as string, accessToken },
|
|
logger: false,
|
|
});
|
|
|
|
await client.connect();
|
|
console.log('Connected to IMAP');
|
|
|
|
const GMAIL_PREFIX_RE = /^\[(?:Gmail|Google Mail)\]\//;
|
|
const SKIP_SUFFIXES = new Set(['All Mail', 'Trash', 'Spam', 'Bin']);
|
|
|
|
const folders = await client.list();
|
|
const db = openEmailDb(userEmail, config.email as string);
|
|
|
|
let seeded = 0;
|
|
|
|
for (const folder of folders) {
|
|
const suffix = folder.path.replace(GMAIL_PREFIX_RE, '');
|
|
const isGmailFolder = suffix !== folder.path;
|
|
if (isGmailFolder && SKIP_SUFFIXES.has(suffix)) continue;
|
|
if (folder.specialUse && ['\\Trash', '\\Junk', '\\All'].includes(folder.specialUse)) continue;
|
|
|
|
try {
|
|
const status = await client.status(folder.path, { uidNext: true, uidValidity: true });
|
|
const lastUid = (status.uidNext ?? 1) - 1;
|
|
const uidValidity = String(status.uidValidity);
|
|
|
|
setSyncMeta(db, `imap_lastuid:${folder.path}`, String(lastUid));
|
|
setSyncMeta(db, `imap_uidvalidity:${folder.path}`, uidValidity);
|
|
|
|
console.log(` ${folder.path}: lastUid=${lastUid}, uidValidity=${uidValidity}`);
|
|
seeded++;
|
|
} catch (err) {
|
|
console.log(` ${folder.path}: skipped (${err instanceof Error ? err.message : err})`);
|
|
}
|
|
}
|
|
|
|
db.close();
|
|
await client.logout();
|
|
|
|
console.log(`\nSeeded ${seeded} folders. Next sync will only fetch new messages.`);
|
|
process.exit(0);
|