aiden-runtime 3.16.0

package/dist/core/bgLLM.js

@@ -0,0 +1,108 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBgLLM = callBgLLM;
+// core/bgLLM.ts — Lightweight LLM caller for background agents.
+// Tries Cerebras first (fast, free), falls back to Ollama.
+// All calls tracked as system cost (not counted toward user budget).
+// Separated from agentLoop.ts to avoid circular imports.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const costTracker_1 = require("./costTracker");
+const CONFIG_PATH = path_1.default.join(process.cwd(), 'config', 'devos.config.json');
+// ── Config helpers ─────────────────────────────────────────────
+function getCerebrasKey() {
+    try {
+        const cfg = JSON.parse(fs_1.default.readFileSync(CONFIG_PATH, 'utf-8'));
+        const api = (cfg.providers?.apis ?? []).find((a) => a.provider === 'cerebras' && a.enabled);
+        if (!api)
+            return '';
+        const key = api.key;
+        return key.startsWith('env:')
+            ? (process.env[key.replace('env:', '')] || '')
+            : key;
+    }
+    catch {
+        return '';
+    }
+}
+function getOllamaModel() {
+    try {
+        const cfg = JSON.parse(fs_1.default.readFileSync(CONFIG_PATH, 'utf-8'));
+        return cfg.model?.activeModel || 'mistral:7b';
+    }
+    catch {
+        return 'mistral:7b';
+    }
+}
+// ── callBgLLM ─────────────────────────────────────────────────
+// Simple single-turn LLM call for background agents.
+// Uses Cerebras → Ollama fallback. Always system cost.
+async function callBgLLM(prompt, traceId) {
+    // Try Cerebras
+    const key = getCerebrasKey();
+    if (key) {
+        try {
+            const r = await fetch('https://api.cerebras.ai/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${key}`,
+                },
+                body: JSON.stringify({
+                    model: 'llama3.1-8b',
+                    messages: [{ role: 'user', content: prompt }],
+                    stream: false,
+                    max_tokens: 2000,
+                }),
+                signal: AbortSignal.timeout(30000),
+            });
+            if (r.ok) {
+                const d = await r.json();
+                const text = d?.choices?.[0]?.message?.content || '';
+                const inputTokens = d?.usage?.prompt_tokens ?? 0;
+                const outputTokens = d?.usage?.completion_tokens ?? 0;
+                try {
+                    costTracker_1.costTracker.trackUsage('cerebras', 'llama3.1-8b', inputTokens, outputTokens, traceId, true);
+                }
+                catch { }
+                if (text)
+                    return text;
+            }
+        }
+        catch { }
+    }
+    // Fallback: Ollama
+    try {
+        const ollamaModel = getOllamaModel();
+        const r = await fetch('http://localhost:11434/api/chat', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: ollamaModel,
+                stream: false,
+                messages: [{ role: 'user', content: prompt }],
+            }),
+            signal: AbortSignal.timeout(60000),
+        });
+        if (r.ok) {
+            const d = await r.json();
+            const text = d?.message?.content || '';
+            try {
+                costTracker_1.costTracker.trackUsage('ollama', ollamaModel, d?.prompt_eval_count ?? 0, d?.eval_count ?? 0, traceId, true);
+            }
+            catch { }
+            return text;
+        }
+    }
+    catch (e) {
+        console.error('[bgLLM] Ollama fallback failed:', e.message);
+    }
+    return '';
+}

package/dist/core/bm25.js

@@ -0,0 +1,68 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BM25 = void 0;
+// core/bm25.ts — Lightweight BM25 ranking. No external dependencies.
+// Okapi BM25 with k1=1.5, b=0.75 (standard defaults).
+class BM25 {
+    constructor() {
+        this.k1 = 1.5;
+        this.b = 0.75;
+        this.corpus = [];
+        this.idf = new Map();
+        this.avgDocLength = 0;
+    }
+    // ── Index ───────────────────────────────────────────────────
+    index(documents) {
+        this.corpus = documents;
+        const N = documents.length;
+        if (N === 0)
+            return;
+        const df = new Map();
+        let totalLength = 0;
+        for (const doc of documents) {
+            totalLength += doc.split(/\s+/).length;
+            const terms = new Set(doc.toLowerCase().split(/\W+/).filter(Boolean));
+            for (const term of terms) {
+                df.set(term, (df.get(term) || 0) + 1);
+            }
+        }
+        this.avgDocLength = totalLength / N;
+        this.idf.clear();
+        for (const [term, freq] of df) {
+            // Robertson-Walker IDF with +1 smoothing
+            this.idf.set(term, Math.log((N - freq + 0.5) / (freq + 0.5) + 1));
+        }
+    }
+    // ── Search ──────────────────────────────────────────────────
+    search(query, topK = 5) {
+        if (this.corpus.length === 0)
+            return [];
+        const queryTerms = query.toLowerCase().split(/\W+/).filter(Boolean);
+        const scores = new Array(this.corpus.length).fill(0);
+        for (const term of queryTerms) {
+            const idf = this.idf.get(term);
+            if (!idf)
+                continue;
+            for (let i = 0; i < this.corpus.length; i++) {
+                const docTerms = this.corpus[i].toLowerCase().split(/\W+/).filter(Boolean);
+                const tf = docTerms.filter(t => t === term).length;
+                if (tf === 0)
+                    continue;
+                const docLength = docTerms.length;
+                const numerator = tf * (this.k1 + 1);
+                const denominator = tf + this.k1 * (1 - this.b + this.b * docLength / this.avgDocLength);
+                scores[i] += idf * (numerator / denominator);
+            }
+        }
+        return scores
+            .map((score, index) => ({ index, score }))
+            .filter(r => r.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+    }
+}
+exports.BM25 = BM25;

package/dist/core/callbackSystem.js

@@ -0,0 +1,64 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callbacks = void 0;
+// ── Registry ──────────────────────────────────────────────────────────────────
+class CallbackRegistry {
+    constructor() {
+        this.handlers = new Map();
+        this.anyHandlers = [];
+    }
+    /**
+     * Subscribe to a specific event.
+     * @returns An unsubscribe function — call it to remove this handler.
+     */
+    on(event, handler) {
+        const list = this.handlers.get(event) ?? [];
+        list.push(handler);
+        this.handlers.set(event, list);
+        return () => {
+            const current = this.handlers.get(event) ?? [];
+            this.handlers.set(event, current.filter(h => h !== handler));
+        };
+    }
+    /**
+     * Subscribe to every event regardless of type.
+     * @returns An unsubscribe function.
+     */
+    onAny(handler) {
+        this.anyHandlers.push(handler);
+        return () => {
+            this.anyHandlers = this.anyHandlers.filter(h => h !== handler);
+        };
+    }
+    /**
+     * Emit an event to all matching subscribers.
+     * Errors thrown by individual handlers are caught and logged — they
+     * never propagate back to the emitter.
+     */
+    async emit(event, sessionId, data = {}) {
+        const payload = {
+            event,
+            timestamp: Date.now(),
+            sessionId,
+            data,
+        };
+        const specific = this.handlers.get(event) ?? [];
+        const all = [...specific, ...this.anyHandlers];
+        if (all.length === 0)
+            return;
+        for (const handler of all) {
+            try {
+                await handler(payload);
+            }
+            catch (e) {
+                console.error(`[Callbacks] Handler error for "${event}": ${e.message}`);
+            }
+        }
+    }
+}
+// ── Singleton ─────────────────────────────────────────────────────────────────
+exports.callbacks = new CallbackRegistry();

package/dist/core/channels/adapter.js

@@ -0,0 +1,6 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/channels/discord.js

@@ -0,0 +1,173 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordAdapter = void 0;
+// core/channels/discord.ts — Discord channel adapter.
+//
+// Config (env vars):
+//   DISCORD_BOT_TOKEN           — required; adapter stays disabled if absent
+//   DISCORD_ALLOWED_GUILDS      — optional comma-separated guild IDs
+//   DISCORD_ALLOWED_CHANNELS    — optional comma-separated channel IDs
+//
+// Features:
+//   - Responds to direct messages and guild messages
+//   - Slash commands: /aiden <prompt>  /aiden-help
+//   - Allowlist enforcement for guilds and channels
+//   - Ignores messages from other bots (no bot loops)
+//   - Graceful degradation: missing token → disabled, no crash
+const discord_js_1 = require("discord.js");
+const gateway_1 = require("../gateway");
+class DiscordAdapter {
+    constructor() {
+        this.name = 'discord';
+        this.client = null;
+        this.healthy = false;
+        this.token = process.env.DISCORD_BOT_TOKEN ?? '';
+        const rawGuilds = process.env.DISCORD_ALLOWED_GUILDS ?? '';
+        const rawChannels = process.env.DISCORD_ALLOWED_CHANNELS ?? '';
+        this.allowedGuilds = rawGuilds ? new Set(rawGuilds.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
+        this.allowedChannels = rawChannels ? new Set(rawChannels.split(',').map(s => s.trim()).filter(Boolean)) : new Set();
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.token) {
+            console.log('[Discord] Disabled — set DISCORD_BOT_TOKEN to enable');
+            return;
+        }
+        this.client = new discord_js_1.Client({
+            intents: [
+                discord_js_1.GatewayIntentBits.Guilds,
+                discord_js_1.GatewayIntentBits.GuildMessages,
+                discord_js_1.GatewayIntentBits.MessageContent,
+                discord_js_1.GatewayIntentBits.DirectMessages,
+            ],
+        });
+        this.client.once(discord_js_1.Events.ClientReady, async (c) => {
+            console.log(`[Discord] Connected as ${c.user.tag}`);
+            this.healthy = true;
+            // Register outbound delivery so gateway.deliver() and broadcast() work
+            gateway_1.gateway.registerChannel('discord', async (msg) => {
+                return this.deliverToChannel(msg.channelId, msg.text);
+            });
+            // Register slash commands globally (takes ~1h to propagate on first run)
+            await this.registerSlashCommands(c.user.id).catch((e) => console.warn('[Discord] Slash command registration failed:', e.message));
+        });
+        this.client.on(discord_js_1.Events.MessageCreate, async (message) => {
+            if (!this.shouldHandle(message.author.id, message.guildId, message.channelId, message.author.bot))
+                return;
+            try {
+                await message.channel.sendTyping?.();
+            }
+            catch { }
+            const response = await this.processMessage(message.channelId, message.author.id, message.content);
+            await message.reply(response.substring(0, 2000)).catch((e) => console.error('[Discord] Reply error:', e.message));
+        });
+        this.client.on(discord_js_1.Events.InteractionCreate, async (interaction) => {
+            if (!interaction.isChatInputCommand())
+                return;
+            const guildId = interaction.guildId;
+            const channelId = interaction.channelId;
+            const userId = interaction.user.id;
+            // Allowlist check
+            if (this.allowedGuilds.size > 0 && guildId && !this.allowedGuilds.has(guildId)) {
+                await interaction.reply({ content: '⚠️ This server is not authorized.', ephemeral: true });
+                return;
+            }
+            if (this.allowedChannels.size > 0 && !this.allowedChannels.has(channelId)) {
+                await interaction.reply({ content: '⚠️ This channel is not authorized.', ephemeral: true });
+                return;
+            }
+            if (interaction.commandName === 'aiden') {
+                const prompt = interaction.options.getString('prompt', true);
+                await interaction.deferReply();
+                const response = await this.processMessage(channelId, userId, prompt);
+                await interaction.editReply(response.substring(0, 2000)).catch((e) => console.error('[Discord] editReply error:', e.message));
+            }
+            else if (interaction.commandName === 'aiden-help') {
+                await interaction.reply({
+                    content: '**Aiden** — your local AI assistant\n\n`/aiden <prompt>` — ask anything\n`/aiden-help` — show this message',
+                    ephemeral: true,
+                });
+            }
+        });
+        try {
+            await this.client.login(this.token);
+        }
+        catch (e) {
+            console.error('[Discord] Login failed:', e.message);
+            this.healthy = false;
+        }
+    }
+    async stop() {
+        this.healthy = false;
+        if (this.client) {
+            gateway_1.gateway.unregisterChannel('discord');
+            await this.client.destroy();
+            this.client = null;
+        }
+        console.log('[Discord] Disconnected');
+    }
+    async send(channelId, message) {
+        await this.deliverToChannel(channelId, message);
+    }
+    isHealthy() { return this.healthy; }
+    // ── Helpers ────────────────────────────────────────────────
+    shouldHandle(authorId, guildId, channelId, isBot) {
+        if (isBot)
+            return false;
+        if (this.allowedGuilds.size > 0 && guildId && !this.allowedGuilds.has(guildId))
+            return false;
+        if (this.allowedChannels.size > 0 && !this.allowedChannels.has(channelId))
+            return false;
+        return true;
+    }
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'discord',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[Discord] routeMessage error:', e.message);
+            return '❌ Something went wrong. Try again.';
+        }
+    }
+    async deliverToChannel(channelId, text) {
+        try {
+            const ch = this.client?.channels.cache.get(channelId);
+            if (ch && (ch instanceof discord_js_1.TextChannel || ch instanceof discord_js_1.DMChannel)) {
+                await ch.send(text.substring(0, 2000));
+                return true;
+            }
+            return false;
+        }
+        catch (e) {
+            console.error('[Discord] Delivery error:', e.message);
+            return false;
+        }
+    }
+    async registerSlashCommands(appId) {
+        const rest = new discord_js_1.REST({ version: '10' }).setToken(this.token);
+        const commands = [
+            new discord_js_1.SlashCommandBuilder()
+                .setName('aiden')
+                .setDescription('Ask Aiden anything')
+                .addStringOption(opt => opt.setName('prompt').setDescription('Your message to Aiden').setRequired(true))
+                .toJSON(),
+            new discord_js_1.SlashCommandBuilder()
+                .setName('aiden-help')
+                .setDescription('Show Aiden capabilities')
+                .toJSON(),
+        ];
+        await rest.put(discord_js_1.Routes.applicationCommands(appId), { body: commands });
+        console.log('[Discord] Slash commands registered globally');
+    }
+}
+exports.DiscordAdapter = DiscordAdapter;

package/dist/core/channels/email.js

@@ -0,0 +1,253 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailAdapter = void 0;
+// core/channels/email.ts — Email-as-interface channel adapter.
+//
+// Aiden acts as an email assistant: users send messages TO a dedicated
+// inbox and Aiden replies via SMTP. Configure a Gmail, Fastmail, or any
+// IMAP/SMTP-capable account. Use an app-specific password for Gmail.
+//
+// Loop prevention:
+//   - Skips messages where From matches EMAIL_SMTP_USER (self-sent)
+//   - Skips messages that already have an X-Aiden-Reply header
+//   - Only processes subjects that don't start with "Re: " already
+//     replied by Aiden
+//
+// Config (env vars):
+//   EMAIL_IMAP_HOST         — e.g. imap.gmail.com
+//   EMAIL_IMAP_PORT         — default 993 (TLS)
+//   EMAIL_IMAP_USER         — your email address
+//   EMAIL_IMAP_PASSWORD     — account or app-specific password
+//   EMAIL_SMTP_HOST         — e.g. smtp.gmail.com
+//   EMAIL_SMTP_PORT         — default 587 (STARTTLS)
+//   EMAIL_SMTP_USER         — usually same as IMAP user
+//   EMAIL_SMTP_PASSWORD     — usually same as IMAP password
+//   EMAIL_ALLOWED_SENDERS   — optional comma-separated from-address allowlist
+//   EMAIL_POLL_INTERVAL     — polling interval in seconds (default 60)
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const gateway_1 = require("../gateway");
+class EmailAdapter {
+    constructor() {
+        this.name = 'email';
+        this.healthy = false;
+        this.pollTimer = null;
+        this.processedIds = new Set();
+        this.transporter = null;
+        this.imapHost = process.env.EMAIL_IMAP_HOST ?? '';
+        this.imapPort = parseInt(process.env.EMAIL_IMAP_PORT ?? '993', 10);
+        this.imapUser = process.env.EMAIL_IMAP_USER ?? '';
+        this.imapPassword = process.env.EMAIL_IMAP_PASSWORD ?? '';
+        this.smtpHost = process.env.EMAIL_SMTP_HOST ?? '';
+        this.smtpPort = parseInt(process.env.EMAIL_SMTP_PORT ?? '587', 10);
+        this.smtpUser = process.env.EMAIL_SMTP_USER ?? '';
+        this.smtpPassword = process.env.EMAIL_SMTP_PASSWORD ?? '';
+        const raw = process.env.EMAIL_ALLOWED_SENDERS ?? '';
+        this.allowedSenders = raw ? new Set(raw.split(',').map(s => s.trim().toLowerCase()).filter(Boolean)) : new Set();
+        this.pollIntervalMs = parseInt(process.env.EMAIL_POLL_INTERVAL ?? '60', 10) * 1000;
+    }
+    // ── Lifecycle ──────────────────────────────────────────────
+    async start() {
+        if (!this.imapHost || !this.imapUser || !this.imapPassword) {
+            console.log('[Email] Disabled — set EMAIL_IMAP_HOST, EMAIL_IMAP_USER, EMAIL_IMAP_PASSWORD to enable');
+            return;
+        }
+        if (!this.smtpHost || !this.smtpUser || !this.smtpPassword) {
+            console.log('[Email] Disabled — set EMAIL_SMTP_HOST, EMAIL_SMTP_USER, EMAIL_SMTP_PASSWORD to enable');
+            return;
+        }
+        // Set up SMTP transporter
+        this.transporter = nodemailer_1.default.createTransport({
+            host: this.smtpHost,
+            port: this.smtpPort,
+            secure: this.smtpPort === 465,
+            auth: {
+                user: this.smtpUser,
+                pass: this.smtpPassword,
+            },
+        });
+        // Verify SMTP connection
+        const smtpOk = await this.transporter.verify().then(() => true).catch(() => false);
+        if (!smtpOk) {
+            console.log('[Email] Disabled — SMTP connection failed. Check EMAIL_SMTP_* settings.');
+            return;
+        }
+        this.healthy = true;
+        console.log(`[Email] Ready — polling ${this.imapUser} every ${this.pollIntervalMs / 1000}s`);
+        // Register outbound delivery
+        gateway_1.gateway.registerChannel('email', async (msg) => {
+            await this.send(msg.channelId, msg.text);
+            return true;
+        });
+        // Initial poll then start interval
+        await this.poll();
+        this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs);
+    }
+    async stop() {
+        this.healthy = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.transporter = null;
+        gateway_1.gateway.unregisterChannel('email');
+        console.log('[Email] Disconnected');
+    }
+    async send(target, message) {
+        if (!this.transporter)
+            return;
+        try {
+            await this.transporter.sendMail({
+                from: this.smtpUser,
+                to: target,
+                subject: 'Message from Aiden',
+                text: message,
+                headers: { 'X-Aiden-Reply': '1' },
+            });
+        }
+        catch (e) {
+            console.error('[Email] send error:', e.message);
+        }
+    }
+    isHealthy() { return this.healthy; }
+    // ── Polling ────────────────────────────────────────────────
+    async poll() {
+        if (!this.healthy)
+            return;
+        let imapSimple;
+        try {
+            imapSimple = require('imap-simple');
+        }
+        catch {
+            return;
+        }
+        let connection = null;
+        try {
+            const config = {
+                imap: {
+                    host: this.imapHost,
+                    port: this.imapPort,
+                    tls: true,
+                    tlsOptions: { rejectUnauthorized: false },
+                    user: this.imapUser,
+                    password: this.imapPassword,
+                    authTimeout: 5000,
+                },
+            };
+            connection = await imapSimple.connect(config);
+            await connection.openBox('INBOX');
+            // Fetch unseen messages
+            const messages = await connection.search(['UNSEEN'], { bodies: ['HEADER', 'TEXT'], markSeen: false });
+            for (const item of messages) {
+                const all = item.parts.find((p) => p.which === 'TEXT');
+                const header = item.parts.find((p) => p.which === 'HEADER');
+                const msgId = item.attributes.uid?.toString() ?? '';
+                if (this.processedIds.has(msgId))
+                    continue;
+                const headers = imapSimple.getParts ? {} : (header?.body ?? {});
+                const fromRaw = (headers['from']?.[0] ?? '').toLowerCase();
+                const subject = (headers['subject']?.[0] ?? '');
+                const aidenHdr = headers['x-aiden-reply']?.[0];
+                // ── Loop prevention ──────────────────────────────────
+                // 1. Skip messages from ourselves
+                if (fromRaw.includes(this.smtpUser.toLowerCase())) {
+                    this.processedIds.add(msgId);
+                    continue;
+                }
+                // 2. Skip if already tagged as an Aiden reply
+                if (aidenHdr) {
+                    this.processedIds.add(msgId);
+                    continue;
+                }
+                // Extract sender email
+                const senderMatch = fromRaw.match(/<([^>]+)>/) ?? [null, fromRaw.trim()];
+                const senderEmail = senderMatch[1] ?? fromRaw.trim();
+                if (!this.isAllowed(senderEmail)) {
+                    this.processedIds.add(msgId);
+                    continue;
+                }
+                const body = all?.body ?? '';
+                if (!body.trim()) {
+                    this.processedIds.add(msgId);
+                    continue;
+                }
+                this.processedIds.add(msgId);
+                // Route message to agent
+                const response = await this.processMessage(senderEmail, senderEmail, this.extractText(body));
+                // Reply via SMTP
+                await this.replyEmail(senderEmail, subject, response);
+                // Mark message as seen
+                try {
+                    await connection.addFlags(item.attributes.uid, '\\Seen');
+                }
+                catch { }
+            }
+        }
+        catch (e) {
+            if (this.healthy) {
+                console.error('[Email] poll error:', e.message);
+            }
+        }
+        finally {
+            if (connection) {
+                try {
+                    connection.end();
+                }
+                catch { }
+            }
+        }
+    }
+    async replyEmail(to, originalSubject, body) {
+        if (!this.transporter)
+            return;
+        const subject = originalSubject.startsWith('Re:') ? originalSubject : `Re: ${originalSubject}`;
+        try {
+            await this.transporter.sendMail({
+                from: this.smtpUser,
+                to,
+                subject,
+                text: body,
+                headers: { 'X-Aiden-Reply': '1' },
+            });
+        }
+        catch (e) {
+            console.error('[Email] reply error:', e.message);
+        }
+    }
+    extractText(raw) {
+        // Strip quoted reply sections and HTML tags for clean prompt
+        return raw
+            .replace(/<[^>]+>/g, '') // remove HTML tags
+            .replace(/^>.*$/gm, '') // remove email quote lines
+            .replace(/\r\n/g, '\n')
+            .trim()
+            .substring(0, 4000); // cap at 4KB
+    }
+    isAllowed(email) {
+        if (this.allowedSenders.size === 0)
+            return true;
+        return this.allowedSenders.has(email.toLowerCase());
+    }
+    async processMessage(channelId, userId, text) {
+        try {
+            return await gateway_1.gateway.routeMessage({
+                channel: 'email',
+                channelId,
+                userId,
+                text,
+                timestamp: Date.now(),
+            });
+        }
+        catch (e) {
+            console.error('[Email] routeMessage error:', e.message);
+            return 'Something went wrong processing your email. Please try again.';
+        }
+    }
+}
+exports.EmailAdapter = EmailAdapter;