@ouro.bot/cli 0.1.0-alpha.450 → 0.1.0-alpha.451

package/dist/mailroom/file-store.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMailroomStore = void 0;
+exports.ingestRawMailToStore = ingestRawMailToStore;
+exports.decryptMessages = decryptMessages;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(filePath, value) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+function compareNewestFirst(left, right) {
+    return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
+}
+class FileMailroomStore {
+    rootDir;
+    constructor(options) {
+        this.rootDir = options.rootDir;
+        ensureDir(this.messagesDir);
+        ensureDir(this.rawDir);
+        ensureDir(this.logsDir);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_file_store_init",
+            message: "file mailroom store initialized",
+            meta: { rootDir: this.rootDir },
+        });
+    }
+    get messagesDir() {
+        return path.join(this.rootDir, "messages");
+    }
+    get rawDir() {
+        return path.join(this.rootDir, "raw");
+    }
+    get logsDir() {
+        return path.join(this.rootDir, "access-log");
+    }
+    messagePath(id) {
+        return path.join(this.messagesDir, `${id}.json`);
+    }
+    rawPath(objectName) {
+        return path.join(this.rootDir, objectName);
+    }
+    accessLogPath(agentId) {
+        return path.join(this.logsDir, `${agentId}.jsonl`);
+    }
+    async putRawMessage(input) {
+        const { message, rawPayload } = await (0, core_1.buildStoredMailMessage)(input);
+        const existing = readJson(this.messagePath(message.id));
+        if (existing) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_store_dedupe",
+                message: "mailroom store deduped existing message",
+                meta: { id: message.id, agentId: message.agentId },
+            });
+            return { created: false, message: existing };
+        }
+        writeJson(this.rawPath(message.rawObject), rawPayload);
+        writeJson(this.messagePath(message.id), message);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_store_message_written",
+            message: "mailroom store wrote message",
+            meta: { id: message.id, agentId: message.agentId },
+        });
+        return { created: true, message };
+    }
+    async getMessage(id) {
+        const message = readJson(this.messagePath(id));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_store_message_read",
+            message: "mailroom store read message",
+            meta: { id, found: message !== null },
+        });
+        return message;
+    }
+    async listMessages(filters) {
+        const messages = fs.readdirSync(this.messagesDir)
+            .filter((name) => name.endsWith(".json"))
+            .map((name) => readJson(path.join(this.messagesDir, name)))
+            .filter((message) => message !== null)
+            .filter((message) => message.agentId === filters.agentId)
+            .filter((message) => filters.placement ? message.placement === filters.placement : true)
+            .filter((message) => filters.compartmentKind ? message.compartmentKind === filters.compartmentKind : true)
+            .filter((message) => filters.source ? message.source === filters.source : true)
+            .sort(compareNewestFirst)
+            .slice(0, filters.limit ?? 20);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_store_messages_listed",
+            message: "mailroom store listed messages",
+            meta: { agentId: filters.agentId, count: messages.length },
+        });
+        return messages;
+    }
+    async readRawPayload(objectName) {
+        const payload = readJson(this.rawPath(objectName));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_store_raw_read",
+            message: "mailroom store read raw payload",
+            meta: { objectName, found: payload !== null },
+        });
+        return payload;
+    }
+    async recordAccess(entry) {
+        const complete = {
+            ...entry,
+            id: `access_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            accessedAt: new Date().toISOString(),
+        };
+        ensureDir(this.logsDir);
+        fs.appendFileSync(this.accessLogPath(entry.agentId), `${JSON.stringify(complete)}\n`, "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_access_recorded",
+            message: "mail access recorded",
+            meta: { agentId: entry.agentId, messageId: entry.messageId ?? null, tool: entry.tool },
+        });
+        return complete;
+    }
+    async listAccessLog(agentId) {
+        const filePath = this.accessLogPath(agentId);
+        if (!fs.existsSync(filePath)) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_access_log_listed",
+                message: "mail access log listed",
+                meta: { agentId, count: 0 },
+            });
+            return [];
+        }
+        const entries = fs.readFileSync(filePath, "utf-8")
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_access_log_listed",
+            message: "mail access log listed",
+            meta: { agentId, count: entries.length },
+        });
+        return entries;
+    }
+}
+exports.FileMailroomStore = FileMailroomStore;
+async function ingestRawMailToStore(input) {
+    const { resolveMailAddress } = await Promise.resolve().then(() => __importStar(require("./core")));
+    const accepted = [];
+    const rejectedRecipients = [];
+    for (const recipient of input.envelope.rcptTo) {
+        const resolved = resolveMailAddress(input.registry, recipient);
+        if (!resolved) {
+            rejectedRecipients.push(recipient);
+            continue;
+        }
+        const result = await input.store.putRawMessage({
+            resolved,
+            envelope: input.envelope,
+            rawMime: input.rawMime,
+            receivedAt: input.receivedAt,
+        });
+        accepted.push(result.message);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_ingest_complete",
+        message: "mail ingest completed",
+        meta: { accepted: accepted.length, rejected: rejectedRecipients.length },
+    });
+    return { accepted, rejectedRecipients };
+}
+function decryptMessages(messages, privateKeys) {
+    const decrypted = messages.map((message) => (0, core_1.decryptStoredMailMessage)(message, privateKeys));
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_messages_decrypted",
+        message: "mail messages decrypted",
+        meta: { count: decrypted.length },
+    });
+    return decrypted;
+}

package/dist/mailroom/mbox-import.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitMboxMessages = splitMboxMessages;
+exports.importMboxToStore = importMboxToStore;
+const mailparser_1 = require("mailparser");
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+function splitMboxMessages(rawMbox) {
+    const text = rawMbox.toString("utf-8");
+    const separators = [...text.matchAll(/^From [^\r\n]*(?:\r?\n)/gm)];
+    if (separators.length === 0) {
+        const trimmed = text.trim();
+        return trimmed ? [Buffer.from(text, "utf-8")] : [];
+    }
+    const messages = separators
+        .map((match, index) => {
+        const start = match.index + match[0].length;
+        const end = index + 1 < separators.length ? separators[index + 1].index : text.length;
+        return text.slice(start, end).replace(/\r?\n$/, "");
+    })
+        .filter((message) => message.trim().length > 0)
+        .map((message) => Buffer.from(message, "utf-8"));
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_mbox_split",
+        message: "mbox payload split into messages",
+        meta: { messages: messages.length },
+    });
+    return messages;
+}
+function findSourceGrant(input) {
+    const ownerEmail = input.ownerEmail ? (0, core_1.normalizeMailAddress)(input.ownerEmail) : undefined;
+    const source = input.source?.trim().toLowerCase();
+    const grants = input.registry.sourceGrants.filter((grant) => {
+        if (!grant.enabled || grant.agentId !== input.agentId)
+            return false;
+        if (ownerEmail && (0, core_1.normalizeMailAddress)(grant.ownerEmail) !== ownerEmail)
+            return false;
+        if (source && grant.source.toLowerCase() !== source)
+            return false;
+        return true;
+    });
+    if (grants.length === 0) {
+        throw new Error(`No enabled Mailroom source grant found for ${input.agentId}${ownerEmail ? ` owner ${ownerEmail}` : ""}${source ? ` source ${source}` : ""}`);
+    }
+    if (grants.length > 1 && !ownerEmail && !source) {
+        throw new Error(`Multiple source grants found for ${input.agentId}; pass --owner-email or --source to choose one`);
+    }
+    return grants[0];
+}
+async function envelopeForMboxMessage(rawMessage, grant) {
+    const parsed = await (0, mailparser_1.simpleParser)(rawMessage);
+    const mailFrom = parsed.from?.value?.[0]?.address;
+    return {
+        mailFrom: mailFrom ? (0, core_1.normalizeMailAddress)(mailFrom) : "",
+        rcptTo: [(0, core_1.normalizeMailAddress)(grant.aliasAddress)],
+        remoteAddress: "mbox-import",
+    };
+}
+async function importMboxToStore(input) {
+    const agentId = input.agentId.toLowerCase();
+    const sourceGrant = findSourceGrant({
+        registry: input.registry,
+        agentId,
+        ownerEmail: input.ownerEmail,
+        source: input.source,
+    });
+    const resolved = (0, core_1.resolveMailAddress)(input.registry, sourceGrant.aliasAddress);
+    /* v8 ignore start -- findSourceGrant and resolveMailAddress share the same registry; this is a corruption guard. @preserve */
+    if (!resolved) {
+        throw new Error(`Source grant alias ${sourceGrant.aliasAddress} is not resolvable`);
+    }
+    /* v8 ignore stop */
+    let imported = 0;
+    let duplicates = 0;
+    const messages = [];
+    const rawMessages = splitMboxMessages(input.rawMbox);
+    for (const rawMessage of rawMessages) {
+        const result = await input.store.putRawMessage({
+            resolved,
+            envelope: await envelopeForMboxMessage(rawMessage, sourceGrant),
+            rawMime: rawMessage,
+            receivedAt: input.importedAt,
+        });
+        messages.push(result.message);
+        if (result.created)
+            imported += 1;
+        else
+            duplicates += 1;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_mbox_imported",
+        message: "mbox mail imported",
+        meta: { agentId, scanned: rawMessages.length, imported, duplicates, grantId: sourceGrant.grantId },
+    });
+    return {
+        agentId,
+        sourceGrant,
+        scanned: rawMessages.length,
+        imported,
+        duplicates,
+        messages,
+    };
+}

package/dist/mailroom/reader.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMailroomConfig = parseMailroomConfig;
+exports.resolveMailroomReader = resolveMailroomReader;
+const path = __importStar(require("node:path"));
+const storage_blob_1 = require("@azure/storage-blob");
+const identity_1 = require("@azure/identity");
+const runtime_1 = require("../nerves/runtime");
+const identity_2 = require("../heart/identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const blob_store_1 = require("./blob-store");
+const file_store_1 = require("./file-store");
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function textField(value, key) {
+    const raw = value[key];
+    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function parseMailroomConfig(value) {
+    if (!isRecord(value))
+        return null;
+    const mailboxAddress = textField(value, "mailboxAddress");
+    if (!mailboxAddress)
+        return null;
+    if (!isRecord(value.privateKeys))
+        return null;
+    const privateKeys = Object.fromEntries(Object.entries(value.privateKeys).filter((entry) => {
+        return typeof entry[0] === "string" && typeof entry[1] === "string" && entry[1].trim().length > 0;
+    }));
+    if (Object.keys(privateKeys).length === 0)
+        return null;
+    const storePath = textField(value, "storePath");
+    const azureAccountUrl = textField(value, "azureAccountUrl");
+    const azureContainer = textField(value, "azureContainer");
+    const azureManagedIdentityClientId = textField(value, "azureManagedIdentityClientId");
+    return {
+        mailboxAddress,
+        ...(storePath ? { storePath } : {}),
+        ...(azureAccountUrl ? { azureAccountUrl } : {}),
+        ...(azureContainer ? { azureContainer } : {}),
+        ...(azureManagedIdentityClientId ? { azureManagedIdentityClientId } : {}),
+        privateKeys,
+    };
+}
+function createMailroomStore(config, agentName) {
+    if (config.azureAccountUrl) {
+        const credential = config.azureManagedIdentityClientId
+            ? new identity_1.DefaultAzureCredential({ managedIdentityClientId: config.azureManagedIdentityClientId })
+            : new identity_1.DefaultAzureCredential();
+        const containerName = config.azureContainer ?? "mailroom";
+        return {
+            store: new blob_store_1.AzureBlobMailroomStore({
+                serviceClient: new storage_blob_1.BlobServiceClient(config.azureAccountUrl, credential),
+                containerName,
+            }),
+            storeKind: "azure-blob",
+            storeLabel: `${config.azureAccountUrl}/${containerName}`,
+        };
+    }
+    const storePath = config.storePath ?? path.join((0, identity_2.getAgentRoot)(agentName), "state", "mailroom");
+    return {
+        store: new file_store_1.FileMailroomStore({ rootDir: storePath }),
+        storeKind: "file",
+        storeLabel: storePath,
+    };
+}
+function resolveMailroomReader(agentName = (0, identity_2.getAgentName)()) {
+    const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
+    if (!runtime.ok) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "auth-required",
+            error: `AUTH_REQUIRED:mailroom -- Mail is not available because ${runtime.itemPath} is ${runtime.reason}. Run 'ouro connect mail --agent ${agentName}' after the vault is unlocked.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const config = parseMailroomConfig(runtime.config.mailroom);
+    if (!config) {
+        const result = {
+            ok: false,
+            agentName,
+            reason: "misconfigured",
+            error: `AUTH_REQUIRED:mailroom -- Missing mailroom mailbox/private key config in vault runtime/config for ${agentName}.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_reader_resolved",
+            message: "mailroom reader resolved",
+            meta: { agentName, status: result.reason },
+        });
+        return result;
+    }
+    const store = createMailroomStore(config, agentName);
+    const result = {
+        ok: true,
+        agentName,
+        config,
+        store: store.store,
+        storeKind: store.storeKind,
+        storeLabel: store.storeLabel,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_reader_resolved",
+        message: "mailroom reader resolved",
+        meta: { agentName, status: "ready", mailboxAddress: config.mailboxAddress, storeKind: store.storeKind },
+    });
+    return result;
+}

package/dist/mailroom/smtp-ingress.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMailroomSmtpServer = createMailroomSmtpServer;
+exports.createMailroomHealthServer = createMailroomHealthServer;
+exports.startMailroomIngress = startMailroomIngress;
+const http = __importStar(require("node:http"));
+const smtp_server_1 = require("smtp-server");
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+const file_store_1 = require("./file-store");
+function collectStream(stream, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        stream.on("data", (chunk) => {
+            total += chunk.byteLength;
+            if (total > maxBytes) {
+                reject(new Error(`message exceeds max size ${maxBytes}`));
+                stream.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+    });
+}
+function sessionRecipients(session) {
+    /* v8 ignore next -- smtp-server supplies rcptTo during DATA; fallback is a defensive harness edge. @preserve */
+    return (session.envelope.rcptTo ?? []).map((address) => (0, core_1.normalizeMailAddress)(address.address));
+}
+function createMailroomSmtpServer(options) {
+    const maxMessageBytes = options.maxMessageBytes ?? 25 * 1024 * 1024;
+    const server = new smtp_server_1.SMTPServer({
+        disabledCommands: ["AUTH", "STARTTLS"],
+        logger: false,
+        onRcptTo(address, _session, callback) {
+            const normalized = (0, core_1.normalizeMailAddress)(address.address);
+            const resolved = (0, core_1.resolveMailAddress)(options.registry, normalized);
+            if (!resolved) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_recipient_rejected",
+                    message: "smtp recipient rejected",
+                    meta: { address: normalized },
+                });
+                const error = new Error(`unknown recipient ${normalized}`);
+                error.responseCode = 550;
+                callback(error);
+                return;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_smtp_recipient_accepted",
+                message: "smtp recipient accepted",
+                meta: { address: normalized, agentId: resolved.agentId },
+            });
+            callback();
+        },
+        async onData(stream, session, callback) {
+            try {
+                const raw = await collectStream(stream, maxMessageBytes);
+                const mailFrom = session.envelope.mailFrom;
+                /* v8 ignore next -- smtp-server exposes normal and null senders as address objects; false/undefined are defensive direct-call states. @preserve */
+                const rawMailFrom = mailFrom === false ? "" : mailFrom?.address ?? "";
+                const envelope = {
+                    mailFrom: rawMailFrom ? (0, core_1.normalizeMailAddress)(rawMailFrom) : "",
+                    rcptTo: sessionRecipients(session),
+                    /* v8 ignore next -- smtp-server network sessions carry remoteAddress; fallback is a defensive direct-call edge. @preserve */
+                    ...(session.remoteAddress ? { remoteAddress: session.remoteAddress } : {}),
+                };
+                const result = await (0, file_store_1.ingestRawMailToStore)({
+                    registry: options.registry,
+                    store: options.store,
+                    envelope,
+                    rawMime: raw,
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.mail_smtp_data_stored",
+                    message: "smtp data stored",
+                    meta: { accepted: result.accepted.length, rejected: result.rejectedRecipients.length },
+                });
+                callback();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.mail_smtp_data_error",
+                    message: "smtp data handling failed",
+                    meta: { error: error instanceof Error ? error.message : String(error) },
+                });
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_smtp_server_created",
+        message: "mailroom smtp server created",
+        meta: { maxMessageBytes },
+    });
+    return server;
+}
+function createMailroomHealthServer(registry) {
+    const server = http.createServer((_request, response) => {
+        const body = JSON.stringify({
+            ok: true,
+            service: "ouro-mailroom",
+            domain: registry.domain,
+            mailboxes: registry.mailboxes.length,
+            sourceGrants: registry.sourceGrants.length,
+        });
+        response.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(body),
+        });
+        response.end(body);
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_health_server_created",
+        message: "mailroom health server created",
+        meta: { domain: registry.domain },
+    });
+    return server;
+}
+function startMailroomIngress(options) {
+    const smtp = createMailroomSmtpServer(options);
+    const health = createMailroomHealthServer(options.registry);
+    /* v8 ignore next -- production/container entrypoints may omit host; unit tests bind loopback explicitly. @preserve */
+    const host = options.host ?? "0.0.0.0";
+    smtp.listen(options.smtpPort, host);
+    health.listen(options.httpPort, host);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_ingress_started",
+        message: "mailroom ingress started",
+        meta: { smtpPort: options.smtpPort, httpPort: options.httpPort, host },
+    });
+    return { smtp, health };
+}

package/dist/mind/friends/channel.js

@@ -46,6 +46,15 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: false,
         maxMessageLength: Infinity,
     },
+    mail: {
+        channel: "mail",
+        senseType: "open",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
     inner: {
         channel: "inner",
         senseType: "internal",

package/dist/mind/friends/types.js

@@ -7,7 +7,7 @@ exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
 exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle", "email-address"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",