@ouro.bot/cli 0.1.0-alpha.475 → 0.1.0-alpha.477

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.477",
+      "changes": [
+        "Hosted Mailroom reads now use per-agent message index blobs, so MCP mail tools and Outlook stop crawling the entire hosted mailbox just to load recent mail.",
+        "Legacy hosted mailboxes can rebuild missing message indexes without reimporting mail, and duplicate or placement-update paths now repair index drift automatically.",
+        "Mail source filtering is now case-insensitive across blob and file mail stores, which keeps delegated-source reads resilient to older mixed-case source labels while the runtime and `ouro.bot` wrapper stay version-synced for the hosted-mail read repair."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.476",
+      "changes": [
+        "`ouro mail import-mbox` now works against hosted Mailroom config by reading public registry coordinates from the owning agent vault instead of requiring local-only registry and store paths.",
+        "Delegated HEY archive imports now stream large local MBOX files into encrypted Mailroom storage with per-message dedupe, so multi-gigabyte hosted backfills can resume safely after interruption.",
+        "Agent Mail docs now teach linked HEY accounts as separate export and forwarding feeders even under one browser login, while keeping one delegated-source provenance lens for the agent."
+      ]
+    },
     {
       "version": "0.1.0-alpha.475",
       "changes": [

package/dist/heart/daemon/cli-exec.js

@@ -80,8 +80,8 @@ const ouro_version_manager_1 = require("../versioning/ouro-version-manager");
 const update_checker_1 = require("../versioning/update-checker");
 const sync_1 = require("../sync");
 const core_1 = require("../../mailroom/core");
-const file_store_1 = require("../../mailroom/file-store");
 const mbox_import_1 = require("../../mailroom/mbox-import");
+const reader_1 = require("../../mailroom/reader");
 const cli_parse_1 = require("./cli-parse");
 const cli_parse_2 = require("./cli-parse");
 const cli_help_1 = require("./cli-help");
@@ -3409,27 +3409,42 @@ async function executeMailImportMbox(command, deps) {
             progress.end();
             throw new Error(`cannot read Mailroom config from ${runtime.itemPath}: ${runtime.error}`);
         }
-        const mailroom = runtime.config.mailroom;
-        if (!mailroom || typeof mailroom !== "object" || Array.isArray(mailroom)) {
+        const mailroom = (0, reader_1.parseMailroomConfig)(runtime.config.mailroom);
+        if (!mailroom) {
             progress.end();
             throw new Error(`missing mailroom config for ${command.agent}; agent-runnable repair: 'ouro connect mail --agent ${command.agent}'`);
         }
-        const registryPath = stringField(mailroom, "registryPath");
-        const storePath = stringField(mailroom, "storePath");
-        if (!registryPath || !storePath) {
+        const hosted = Boolean(mailroom.azureAccountUrl);
+        if (hosted) {
+            const registryAzureAccountUrl = mailroom.registryAzureAccountUrl?.trim() ?? "";
+            const registryBlob = mailroom.registryBlob?.trim() ?? "";
+            if (!registryAzureAccountUrl || !registryBlob) {
+                progress.end();
+                throw new Error(`mailroom config for ${command.agent} is missing hosted registry coordinates; agent-runnable repair: 'ouro connect mail --agent ${command.agent}'`);
+            }
+        }
+        else {
+            const registryPath = mailroom.registryPath?.trim() ?? "";
+            const storePath = mailroom.storePath?.trim() ?? "";
+            if (!registryPath || !storePath) {
+                progress.end();
+                throw new Error(`mailroom config for ${command.agent} is missing registryPath/storePath; agent-runnable repair: 'ouro connect mail --agent ${command.agent}'`);
+            }
+        }
+        const resolved = (0, reader_1.resolveMailroomReader)(command.agent);
+        if (!resolved.ok) {
             progress.end();
-            throw new Error(`mailroom config for ${command.agent} is missing registryPath/storePath; agent-runnable repair: 'ouro connect mail --agent ${command.agent}'`);
+            throw new Error(resolved.error);
         }
         progress.updateDetail("reading registry and MBOX");
-        const registry = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+        const registry = await (0, reader_1.readMailroomRegistry)(resolved.config);
         const filePath = path.resolve(command.filePath);
-        const rawMbox = fs.readFileSync(filePath);
         progress.updateDetail("importing delegated mail");
-        const result = await (0, mbox_import_1.importMboxToStore)({
+        const result = await (0, mbox_import_1.importMboxFileToStore)({
             registry,
-            store: new file_store_1.FileMailroomStore({ rootDir: storePath }),
+            store: resolved.store,
             agentId: command.agent,
-            rawMbox,
+            filePath,
             ownerEmail: command.ownerEmail,
             source: command.source,
         });
@@ -3454,6 +3469,49 @@ async function executeMailImportMbox(command, deps) {
         throw error;
     }
 }
+async function executeMailBackfillIndexes(command, deps) {
+    const progress = createHumanCommandProgress(deps, "mail index repair");
+    try {
+        progress.startPhase("resolving Mailroom store");
+        const resolved = (0, reader_1.resolveMailroomReader)(command.agent);
+        if (!resolved.ok) {
+            progress.end();
+            throw new Error(resolved.error);
+        }
+        if (resolved.storeKind !== "azure-blob") {
+            progress.completePhase("resolving Mailroom store", "not needed");
+            progress.end();
+            const message = [
+                `Hosted mail index backfill not needed for ${command.agent}`,
+                `store: ${resolved.storeLabel}`,
+                "This agent is using the local file Mailroom store, so recent mail reads do not depend on hosted blob indexes.",
+            ].join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        const store = resolved.store;
+        if (typeof store.backfillMessageIndexes !== "function") {
+            progress.end();
+            throw new Error(`hosted Mailroom store for ${command.agent} does not expose index backfill`);
+        }
+        progress.updateDetail("backfilling hosted message indexes");
+        const indexed = await store.backfillMessageIndexes(command.agent);
+        progress.completePhase("resolving Mailroom store", "backfilled");
+        progress.end();
+        const message = [
+            `Backfilled hosted mail indexes for ${command.agent}`,
+            `store: ${resolved.storeLabel}`,
+            `indexed: ${indexed}`,
+            "Safe to rerun. Existing index entries are rewritten in place.",
+        ].join("\n");
+        deps.writeStdout(message);
+        return message;
+    }
+    catch (error) {
+        progress.end();
+        throw error;
+    }
+}
 async function executeConnectProviders(agent, deps) {
     const promptInput = deps.promptInput;
     if (!promptInput) {
@@ -4874,6 +4932,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     if (command.kind === "mail.import-mbox") {
         return executeMailImportMbox(command, deps);
     }
+    if (command.kind === "mail.backfill-indexes") {
+        return executeMailBackfillIndexes(command, deps);
+    }
     if (command.kind === "daemon.up") {
         // ── dev mode cleanup: delete dev-config.json so the wrapper stops dispatching to dev repo ──
         /* v8 ignore start -- dev-config cleanup: requires real filesystem state @preserve */

package/dist/heart/daemon/cli-help.js

@@ -179,10 +179,10 @@ exports.COMMAND_REGISTRY = {
     },
     mail: {
         category: "Auth",
-        description: "Import delegated mail into the agent Mailroom substrate",
-        usage: "ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]",
+        description: "Import delegated mail and repair hosted Mailroom mailbox indexes",
+        usage: "ouro mail <import-mbox|backfill-indexes> [--agent <name>]",
         example: "ouro mail import-mbox --file ~/Downloads/hey.mbox --owner-email ari@mendelow.me --source hey --agent slugger",
-        subcommands: ["import-mbox"],
+        subcommands: ["import-mbox", "backfill-indexes"],
     },
     use: {
         category: "Auth",
@@ -326,6 +326,11 @@ const SUBCOMMAND_HELP = {
         usage: "ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]",
         example: "ouro mail import-mbox --file ~/Downloads/hey.mbox --owner-email ari@mendelow.me --source hey --agent slugger",
     },
+    "mail backfill-indexes": {
+        description: "Rebuild hosted blob mailbox indexes for faster recent-mail reads after large legacy imports or drift repair.",
+        usage: "ouro mail backfill-indexes [--agent <name>]",
+        example: "ouro mail backfill-indexes --agent slugger",
+    },
     "provider refresh": {
         description: "Reload this agent's provider credentials from its vault into daemon memory",
         usage: "ouro provider refresh [--agent <name>]",

package/dist/heart/daemon/cli-parse.js

@@ -87,6 +87,7 @@ function usage() {
         "  ouro account ensure [--agent <name>] [--owner-email <email> --source <label>|--no-delegated-source] [--rotate-missing-mail-keys]",
         "  ouro connect [providers|perplexity|embeddings|teams|bluebubbles|mail] [--agent <name>] [--owner-email <email> --source <label>|--no-delegated-source] [--rotate-missing-mail-keys]",
         "  ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]",
+        "  ouro mail backfill-indexes [--agent <name>]",
         "  ouro auth verify [--agent <name>] [--provider <provider>]",
         "  ouro auth switch [--agent <name>] --provider <provider>",
         "  ouro vault create [--agent <name>] --email <email> [--server <url>] [--store <store>]",
@@ -884,8 +885,18 @@ function parseConnectCommand(args) {
 }
 function parseMailCommand(args) {
     const [sub, ...subArgs] = args;
+    const usageText = "Usage: ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]\n       ouro mail backfill-indexes [--agent <name>]";
+    if (sub === "backfill-indexes") {
+        const { agent, rest } = extractAgentFlag(subArgs);
+        if (rest.length > 0)
+            throw new Error(usageText);
+        return {
+            kind: "mail.backfill-indexes",
+            ...(agent ? { agent } : {}),
+        };
+    }
     if (sub !== "import-mbox") {
-        throw new Error("Usage: ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]");
+        throw new Error(usageText);
     }
     const { agent, rest } = extractAgentFlag(subArgs);
     let filePath;
@@ -905,10 +916,10 @@ function parseMailCommand(args) {
             source = rest[++i];
             continue;
         }
-        throw new Error("Usage: ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]");
+        throw new Error(usageText);
     }
     if (!filePath) {
-        throw new Error("Usage: ouro mail import-mbox --file <path> [--owner-email <email>] [--source <label>] [--agent <name>]");
+        throw new Error(usageText);
     }
     return {
         kind: "mail.import-mbox",

package/dist/mailroom/blob-store.js

@@ -4,6 +4,12 @@ exports.AzureBlobMailroomStore = void 0;
 exports.decryptBlobMessages = decryptBlobMessages;
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
+const MESSAGE_INDEX_PREFIX = "message-index";
+const MESSAGE_INDEX_SORT_MAX_MS = 9_999_999_999_999;
+const MESSAGE_INDEX_SORT_WIDTH = 13;
+const MESSAGE_INDEX_NO_SOURCE = "~";
+const MESSAGE_INDEX_BACKFILL_CONCURRENCY = 16;
+const MESSAGE_LIST_SCAN_CONCURRENCY = 32;
 function compareNewestFirst(left, right) {
     return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
 }
@@ -18,6 +24,73 @@ async function downloadJson(blob) {
         return null;
     return JSON.parse((await blob.downloadToBuffer()).toString("utf-8"));
 }
+function encodeSourceToken(source) {
+    return source ? encodeURIComponent(source.toLowerCase()) : MESSAGE_INDEX_NO_SOURCE;
+}
+function decodeSourceToken(token) {
+    return token === MESSAGE_INDEX_NO_SOURCE ? undefined : decodeURIComponent(token);
+}
+function parseSortMs(receivedAt) {
+    const parsed = Date.parse(receivedAt);
+    if (!Number.isFinite(parsed))
+        return 0;
+    return Math.max(0, Math.min(MESSAGE_INDEX_SORT_MAX_MS, parsed));
+}
+function messageIndexPrefix(agentId) {
+    return `${MESSAGE_INDEX_PREFIX}/${agentId}/`;
+}
+function messageIndexBlobName(message) {
+    const sortKey = String(MESSAGE_INDEX_SORT_MAX_MS - parseSortMs(message.receivedAt)).padStart(MESSAGE_INDEX_SORT_WIDTH, "0");
+    return `${messageIndexPrefix(message.agentId)}${sortKey}__${message.compartmentKind}__${message.placement}__${encodeSourceToken(message.source)}__${message.id}.json`;
+}
+function messageIndexRecord(message) {
+    return {
+        schemaVersion: 1,
+        id: message.id,
+        agentId: message.agentId,
+        compartmentKind: message.compartmentKind,
+        placement: message.placement,
+        ...(message.source ? { source: message.source } : {}),
+        receivedAt: message.receivedAt,
+    };
+}
+function parseMessageIndexBlobName(name) {
+    if (!name.startsWith(`${MESSAGE_INDEX_PREFIX}/`) || !name.endsWith(".json"))
+        return null;
+    const parts = name.split("/");
+    if (parts.length !== 3)
+        return null;
+    const agentId = parts[1];
+    const stem = parts[2].slice(0, -5);
+    const [sortKey, compartmentKind, placement, sourceToken, ...idParts] = stem.split("__");
+    if (!sortKey || !compartmentKind || !placement || !sourceToken || idParts.length === 0)
+        return null;
+    if (compartmentKind !== "native" && compartmentKind !== "delegated")
+        return null;
+    const receivedAtMs = MESSAGE_INDEX_SORT_MAX_MS - Number.parseInt(sortKey, 10);
+    return {
+        schemaVersion: 1,
+        id: idParts.join("__"),
+        agentId,
+        compartmentKind,
+        placement: placement,
+        ...(decodeSourceToken(sourceToken) ? { source: decodeSourceToken(sourceToken) } : {}),
+        receivedAt: Number.isFinite(receivedAtMs) ? new Date(receivedAtMs).toISOString() : new Date(0).toISOString(),
+    };
+}
+function sourceMatchesFilter(source, filter) {
+    if (!filter)
+        return true;
+    if (!source)
+        return false;
+    return source.toLowerCase() === filter.toLowerCase();
+}
+function messageMatchesFilters(message, filters) {
+    return message.agentId === filters.agentId &&
+        (filters.placement ? message.placement === filters.placement : true) &&
+        (filters.compartmentKind ? message.compartmentKind === filters.compartmentKind : true) &&
+        sourceMatchesFilter(message.source, filters.source);
+}
 class AzureBlobMailroomStore {
     serviceClient;
     containerName;
@@ -44,6 +117,9 @@ class AzureBlobMailroomStore {
     messageBlob(id) {
         return this.container.getBlockBlobClient(`messages/${id}.json`);
     }
+    messageIndexBlob(name) {
+        return this.container.getBlockBlobClient(name);
+    }
     candidateBlob(id) {
         return this.container.getBlockBlobClient(`candidates/${id}.json`);
     }
@@ -59,11 +135,92 @@ class AzureBlobMailroomStore {
     outboundBlob(id) {
         return this.container.getBlockBlobClient(`outbound/${id}.json`);
     }
+    async putMessageIndex(message) {
+        await this.messageIndexBlob(messageIndexBlobName(message)).uploadData(blobText(messageIndexRecord(message)));
+    }
+    async removeMessageIndex(message) {
+        await this.messageIndexBlob(messageIndexBlobName(message)).deleteIfExists();
+    }
+    async listMessagesLegacy(filters) {
+        const messageBlobNames = [];
+        for await (const item of this.container.listBlobsFlat({ prefix: "messages/" })) {
+            messageBlobNames.push(item.name);
+        }
+        const matches = [];
+        const limit = filters.limit ?? 20;
+        let nextIndex = 0;
+        const worker = async () => {
+            while (nextIndex < messageBlobNames.length) {
+                const current = messageBlobNames[nextIndex];
+                nextIndex += 1;
+                const message = await downloadJson(this.container.getBlockBlobClient(current));
+                if (!message || !messageMatchesFilters(message, filters))
+                    continue;
+                matches.push(message);
+                matches.sort(compareNewestFirst);
+                if (matches.length > limit)
+                    matches.length = limit;
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(MESSAGE_LIST_SCAN_CONCURRENCY, Math.max(messageBlobNames.length, 1)) }, async () => worker()));
+        return matches.sort(compareNewestFirst).slice(0, limit);
+    }
+    async listMessagesFromIndexes(filters) {
+        const messageIds = [];
+        let sawIndex = false;
+        for await (const item of this.container.listBlobsFlat({ prefix: messageIndexPrefix(filters.agentId) })) {
+            sawIndex = true;
+            const parsed = parseMessageIndexBlobName(item.name);
+            if (!parsed || !messageMatchesFilters(parsed, filters))
+                continue;
+            messageIds.push(parsed.id);
+            if (messageIds.length >= (filters.limit ?? 20))
+                break;
+        }
+        if (!sawIndex)
+            return null;
+        return (await Promise.all(messageIds.map(async (id) => downloadJson(this.messageBlob(id)))))
+            .filter((message) => message !== null)
+            .filter((message) => messageMatchesFilters(message, filters))
+            .sort(compareNewestFirst)
+            .slice(0, filters.limit ?? 20);
+    }
+    async backfillMessageIndexes(agentId) {
+        await this.ensureContainer();
+        const messageBlobNames = [];
+        for await (const item of this.container.listBlobsFlat({ prefix: "messages/" })) {
+            messageBlobNames.push(item.name);
+        }
+        let indexed = 0;
+        let nextIndex = 0;
+        const worker = async () => {
+            while (nextIndex < messageBlobNames.length) {
+                const current = messageBlobNames[nextIndex];
+                nextIndex += 1;
+                const message = await downloadJson(this.container.getBlockBlobClient(current));
+                if (!message)
+                    continue;
+                if (agentId && message.agentId !== agentId)
+                    continue;
+                await this.messageIndexBlob(messageIndexBlobName(message)).uploadData(blobText(messageIndexRecord(message)));
+                indexed += 1;
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(MESSAGE_INDEX_BACKFILL_CONCURRENCY, Math.max(messageBlobNames.length, 1)) }, async () => worker()));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_index_backfilled",
+            message: "azure blob mailroom message indexes backfilled",
+            meta: { agentId: agentId ?? null, indexed },
+        });
+        return indexed;
+    }
     async putRawMessage(input) {
         await this.ensureContainer();
         const { message, rawPayload, candidate } = await (0, core_1.buildStoredMailMessage)(input);
         const existing = await downloadJson(this.messageBlob(message.id));
         if (existing) {
+            await this.putMessageIndex(existing);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.mail_blob_store_dedupe",
@@ -74,6 +231,7 @@ class AzureBlobMailroomStore {
         }
         await this.rawBlob(message.rawObject).uploadData(blobText(rawPayload));
         await this.messageBlob(message.id).uploadData(blobText(message));
+        await this.putMessageIndex(message);
         if (candidate) {
             await this.candidateBlob(candidate.id).uploadData(blobText(candidate));
         }
@@ -98,24 +256,17 @@ class AzureBlobMailroomStore {
     }
     async listMessages(filters) {
         await this.ensureContainer();
-        const messages = [];
-        for await (const item of this.container.listBlobsFlat({ prefix: "messages/" })) {
-            const message = await downloadJson(this.container.getBlockBlobClient(item.name));
-            if (message)
-                messages.push(message);
+        let filtered = await this.listMessagesFromIndexes(filters);
+        let source = "index";
+        if (filtered === null) {
+            filtered = await this.listMessagesLegacy(filters);
+            source = "legacy";
         }
-        const filtered = messages
-            .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_blob_store_messages_listed",
             message: "azure blob mailroom store listed messages",
-            meta: { agentId: filters.agentId, count: filtered.length },
+            meta: { agentId: filters.agentId, count: filtered.length, source },
         });
         return filtered;
     }
@@ -134,6 +285,8 @@ class AzureBlobMailroomStore {
         }
         const updated = { ...message, placement };
         await blob.uploadData(blobText(updated));
+        await this.removeMessageIndex(message);
+        await this.putMessageIndex(updated);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_blob_store_message_placement_updated",

package/dist/mailroom/file-store.js

@@ -61,6 +61,13 @@ function compareNewestFirst(left, right) {
 function compareCandidatesNewestFirst(left, right) {
     return Date.parse(right.lastSeenAt) - Date.parse(left.lastSeenAt);
 }
+function sourceMatchesFilter(source, filter) {
+    if (!filter)
+        return true;
+    if (!source)
+        return false;
+    return source.toLowerCase() === filter.toLowerCase();
+}
 class FileMailroomStore {
     rootDir;
     constructor(options) {
@@ -157,7 +164,7 @@ class FileMailroomStore {
             .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)
+            .filter((message) => sourceMatchesFilter(message.source, filters.source))
             .sort(compareNewestFirst)
             .slice(0, filters.limit ?? 20);
         (0, runtime_1.emitNervesEvent)({

package/dist/mailroom/mbox-import.js

@@ -1,8 +1,42 @@
 "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.splitMboxMessages = splitMboxMessages;
 exports.importMboxToStore = importMboxToStore;
-const mailparser_1 = require("mailparser");
+exports.importMboxFileToStore = importMboxFileToStore;
+const fs = __importStar(require("node:fs"));
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
 function splitMboxMessages(rawMbox) {
@@ -28,6 +62,65 @@ function splitMboxMessages(rawMbox) {
     });
     return messages;
 }
+function trimTrailingLineEnding(message) {
+    if (message.length >= 2 && message[message.length - 2] === 0x0d && message[message.length - 1] === 0x0a) {
+        return message.subarray(0, -2);
+    }
+    if (message.length >= 1 && message[message.length - 1] === 0x0a) {
+        return message.subarray(0, -1);
+    }
+    return message;
+}
+function isSeparatorLine(line) {
+    return line.length >= 5 &&
+        line[0] === 0x46 &&
+        line[1] === 0x72 &&
+        line[2] === 0x6f &&
+        line[3] === 0x6d &&
+        line[4] === 0x20;
+}
+async function* streamMboxMessagesFromFile(filePath) {
+    const stream = fs.createReadStream(filePath);
+    let pending = Buffer.alloc(0);
+    let currentParts = [];
+    const flushCurrent = () => {
+        if (currentParts.length === 0)
+            return null;
+        const message = trimTrailingLineEnding(Buffer.concat(currentParts));
+        currentParts = [];
+        return message;
+    };
+    for await (const chunk of stream) {
+        pending = pending.length > 0 ? Buffer.concat([pending, chunk]) : Buffer.from(chunk);
+        let newlineIndex = pending.indexOf(0x0a);
+        while (newlineIndex >= 0) {
+            const line = pending.subarray(0, newlineIndex + 1);
+            pending = pending.subarray(newlineIndex + 1);
+            if (isSeparatorLine(line)) {
+                const message = flushCurrent();
+                if (message && message.length > 0)
+                    yield message;
+            }
+            else {
+                currentParts.push(Buffer.from(line));
+            }
+            newlineIndex = pending.indexOf(0x0a);
+        }
+    }
+    if (pending.length > 0) {
+        if (isSeparatorLine(pending)) {
+            const message = flushCurrent();
+            if (message && message.length > 0)
+                yield message;
+        }
+        else {
+            currentParts.push(Buffer.from(pending));
+        }
+    }
+    const finalMessage = flushCurrent();
+    if (finalMessage && finalMessage.length > 0)
+        yield finalMessage;
+}
 function findSourceGrant(input) {
     const ownerEmail = input.ownerEmail ? (0, core_1.normalizeMailAddress)(input.ownerEmail) : undefined;
     const source = input.source?.trim().toLowerCase();
@@ -48,9 +141,9 @@ function findSourceGrant(input) {
     }
     return grants[0];
 }
-async function parseMboxMessage(rawMessage, grant) {
-    const parsed = await (0, mailparser_1.simpleParser)(rawMessage);
-    const mailFrom = parsed.from?.value?.[0]?.address;
+function parseMboxMessage(rawMessage, grant) {
+    const mailFrom = extractHeaderAddress(rawMessage, "from");
+    const messageDate = extractHeaderDate(rawMessage, "date");
     return {
         rawMessage,
         envelope: {
@@ -58,7 +151,7 @@ async function parseMboxMessage(rawMessage, grant) {
             rcptTo: [(0, core_1.normalizeMailAddress)(grant.aliasAddress)],
             remoteAddress: "mbox-import",
         },
-        ...(parsed.date ? { messageDate: parsed.date } : {}),
+        ...(messageDate ? { messageDate } : {}),
     };
 }
 function latestMessageDate(messages) {
@@ -69,6 +162,52 @@ function latestMessageDate(messages) {
         return null;
     return new Date(Math.max(...timestamps)).toISOString();
 }
+function readHeaderBlock(rawMessage) {
+    const crlfBoundary = rawMessage.indexOf("\r\n\r\n");
+    if (crlfBoundary >= 0) {
+        return rawMessage.subarray(0, crlfBoundary).toString("utf-8");
+    }
+    const lfBoundary = rawMessage.indexOf("\n\n");
+    if (lfBoundary >= 0) {
+        return rawMessage.subarray(0, lfBoundary).toString("utf-8");
+    }
+    return rawMessage.toString("utf-8");
+}
+function extractHeaderValue(rawMessage, headerName) {
+    const target = `${headerName.toLowerCase()}:`;
+    let currentHeader = "";
+    const unfoldedHeaders = [];
+    for (const line of readHeaderBlock(rawMessage).split(/\r?\n/)) {
+        if (/^[ \t]/.test(line) && currentHeader) {
+            currentHeader += ` ${line.trim()}`;
+            continue;
+        }
+        if (currentHeader)
+            unfoldedHeaders.push(currentHeader);
+        currentHeader = line;
+    }
+    if (currentHeader)
+        unfoldedHeaders.push(currentHeader);
+    const match = unfoldedHeaders.find((line) => line.toLowerCase().startsWith(target));
+    return match ? match.slice(target.length).trim() : "";
+}
+function extractHeaderAddress(rawMessage, headerName) {
+    const value = extractHeaderValue(rawMessage, headerName);
+    if (!value)
+        return "";
+    const bracketed = value.match(/<([^>]+)>/);
+    if (bracketed?.[1])
+        return bracketed[1];
+    const plain = value.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i);
+    return plain?.[0] ?? "";
+}
+function extractHeaderDate(rawMessage, headerName) {
+    const value = extractHeaderValue(rawMessage, headerName);
+    if (!value)
+        return undefined;
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) ? parsed : undefined;
+}
 function historicalImportClassification(resolvedPlacement, sourceGrant) {
     return {
         placement: resolvedPlacement,
@@ -76,61 +215,124 @@ function historicalImportClassification(resolvedPlacement, sourceGrant) {
         trustReason: `delegated source grant ${sourceGrant.source} historical 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 */
+async function importParsedMessagesToStore(input) {
     let imported = 0;
     let duplicates = 0;
     const messages = [];
-    const rawMessages = splitMboxMessages(input.rawMbox);
-    const parsedMessages = await Promise.all(rawMessages.map((rawMessage) => parseMboxMessage(rawMessage, sourceGrant)));
+    let scanned = 0;
     const importedAt = (input.importedAt ?? new Date()).toISOString();
-    const sourceFreshThrough = latestMessageDate(parsedMessages);
-    for (const parsedMessage of parsedMessages) {
-        const result = await input.store.putRawMessage({
-            resolved,
-            envelope: parsedMessage.envelope,
-            rawMime: parsedMessage.rawMessage,
-            receivedAt: parsedMessage.messageDate ?? input.importedAt,
-            ingest: {
-                schemaVersion: 1,
-                kind: "mbox-import",
-                importedAt,
-                sourceFreshThrough,
-                attentionSuppressed: true,
-            },
-            classification: historicalImportClassification(resolved.defaultPlacement, sourceGrant),
+    const sourceFreshThrough = input.sourceFreshThrough ?? null;
+    const maxConcurrency = Math.max(1, input.maxConcurrency ?? 1);
+    const inFlight = new Set();
+    const enqueue = (parsedMessage) => {
+        const task = (async () => {
+            const result = await input.store.putRawMessage({
+                resolved: input.resolved,
+                envelope: parsedMessage.envelope,
+                rawMime: parsedMessage.rawMessage,
+                receivedAt: parsedMessage.messageDate ?? input.importedAt,
+                ingest: {
+                    schemaVersion: 1,
+                    kind: "mbox-import",
+                    importedAt,
+                    sourceFreshThrough,
+                    attentionSuppressed: true,
+                },
+                classification: historicalImportClassification(input.resolved.defaultPlacement, input.sourceGrant),
+            });
+            if (input.collectMessages !== false)
+                messages.push(result.message);
+            if (result.created)
+                imported += 1;
+            else
+                duplicates += 1;
+        })().finally(() => {
+            inFlight.delete(task);
         });
-        messages.push(result.message);
-        if (result.created)
-            imported += 1;
-        else
-            duplicates += 1;
+        inFlight.add(task);
+        return task;
+    };
+    for await (const parsedMessage of input.parsedMessages) {
+        scanned += 1;
+        enqueue(parsedMessage);
+        if (inFlight.size >= maxConcurrency) {
+            await Promise.race(inFlight);
+        }
     }
+    await Promise.all(inFlight);
     (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 },
+        meta: { agentId: input.sourceGrant.agentId.toLowerCase(), scanned, imported, duplicates, grantId: input.sourceGrant.grantId },
     });
     return {
-        agentId,
-        sourceGrant,
-        scanned: rawMessages.length,
+        agentId: input.sourceGrant.agentId.toLowerCase(),
+        sourceGrant: input.sourceGrant,
+        scanned,
         imported,
         duplicates,
         sourceFreshThrough,
         messages,
     };
 }
+async function scanMboxFileFreshness(filePath, sourceGrant) {
+    let latestTimestamp = Number.NEGATIVE_INFINITY;
+    for await (const rawMessage of streamMboxMessagesFromFile(filePath)) {
+        const parsedMessage = parseMboxMessage(rawMessage, sourceGrant);
+        if (parsedMessage.messageDate) {
+            latestTimestamp = Math.max(latestTimestamp, parsedMessage.messageDate.getTime());
+        }
+    }
+    return Number.isFinite(latestTimestamp) ? new Date(latestTimestamp).toISOString() : null;
+}
+function resolveImportTarget(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 */
+    return { agentId, sourceGrant, resolved };
+}
+async function importMboxToStore(input) {
+    const target = resolveImportTarget(input);
+    const rawMessages = splitMboxMessages(input.rawMbox);
+    const parsedMessages = rawMessages.map((rawMessage) => parseMboxMessage(rawMessage, target.sourceGrant));
+    const sourceFreshThrough = latestMessageDate(parsedMessages);
+    return importParsedMessagesToStore({
+        sourceGrant: target.sourceGrant,
+        resolved: target.resolved,
+        store: input.store,
+        parsedMessages,
+        importedAt: input.importedAt,
+        collectMessages: true,
+        sourceFreshThrough,
+    });
+}
+async function importMboxFileToStore(input) {
+    const target = resolveImportTarget(input);
+    const sourceFreshThrough = await scanMboxFileFreshness(input.filePath, target.sourceGrant);
+    async function* parsedMessages() {
+        for await (const rawMessage of streamMboxMessagesFromFile(input.filePath)) {
+            yield parseMboxMessage(rawMessage, target.sourceGrant);
+        }
+    }
+    return importParsedMessagesToStore({
+        sourceGrant: target.sourceGrant,
+        resolved: target.resolved,
+        store: input.store,
+        parsedMessages: parsedMessages(),
+        importedAt: input.importedAt,
+        collectMessages: false,
+        sourceFreshThrough,
+        maxConcurrency: 8,
+    });
+}

package/dist/mailroom/reader.js

@@ -34,7 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMailroomConfig = parseMailroomConfig;
+exports.readMailroomRegistry = readMailroomRegistry;
 exports.resolveMailroomReader = resolveMailroomReader;
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const storage_blob_1 = require("@azure/storage-blob");
 const identity_1 = require("@azure/identity");
@@ -71,6 +73,9 @@ function parseMailroomConfig(value) {
     const storePath = textField(value, "storePath");
     const azureAccountUrl = textField(value, "azureAccountUrl");
     const azureContainer = textField(value, "azureContainer");
+    const registryAzureAccountUrl = textField(value, "registryAzureAccountUrl");
+    const registryContainer = textField(value, "registryContainer");
+    const registryBlob = textField(value, "registryBlob");
     const azureManagedIdentityClientId = textField(value, "azureManagedIdentityClientId");
     const smtpPort = numberField(value, "smtpPort");
     const httpPort = numberField(value, "httpPort");
@@ -86,6 +91,9 @@ function parseMailroomConfig(value) {
         ...(storePath ? { storePath } : {}),
         ...(azureAccountUrl ? { azureAccountUrl } : {}),
         ...(azureContainer ? { azureContainer } : {}),
+        ...(registryAzureAccountUrl ? { registryAzureAccountUrl } : {}),
+        ...(registryContainer ? { registryContainer } : {}),
+        ...(registryBlob ? { registryBlob } : {}),
         ...(azureManagedIdentityClientId ? { azureManagedIdentityClientId } : {}),
         ...(smtpPort !== undefined ? { smtpPort } : {}),
         ...(httpPort !== undefined ? { httpPort } : {}),
@@ -96,15 +104,17 @@ function parseMailroomConfig(value) {
         privateKeys,
     };
 }
+function createBlobCredential(config) {
+    return config.azureManagedIdentityClientId
+        ? new identity_1.DefaultAzureCredential({ managedIdentityClientId: config.azureManagedIdentityClientId })
+        : new identity_1.DefaultAzureCredential();
+}
 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),
+                serviceClient: new storage_blob_1.BlobServiceClient(config.azureAccountUrl, createBlobCredential(config)),
                 containerName,
             }),
             storeKind: "azure-blob",
@@ -118,6 +128,23 @@ function createMailroomStore(config, agentName) {
         storeLabel: storePath,
     };
 }
+async function readMailroomRegistry(config) {
+    if (config.registryPath) {
+        return JSON.parse(fs.readFileSync(config.registryPath, "utf-8"));
+    }
+    const registryAzureAccountUrl = config.registryAzureAccountUrl ?? config.azureAccountUrl;
+    const registryContainer = config.registryContainer ?? config.azureContainer ?? "mailroom";
+    const registryBlob = config.registryBlob;
+    if (!registryAzureAccountUrl || !registryBlob) {
+        throw new Error("mailroom config is missing registryPath or hosted registry coordinates");
+    }
+    const serviceClient = new storage_blob_1.BlobServiceClient(registryAzureAccountUrl, createBlobCredential(config));
+    const blobClient = serviceClient.getContainerClient(registryContainer).getBlockBlobClient(registryBlob);
+    if (!await blobClient.exists()) {
+        throw new Error(`mailroom registry blob not found: ${registryAzureAccountUrl}/${registryContainer}/${registryBlob}`);
+    }
+    return JSON.parse((await blobClient.downloadToBuffer()).toString("utf-8"));
+}
 function resolveMailroomReader(agentName = (0, identity_2.getAgentName)()) {
     const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
     if (!runtime.ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.475",
+  "version": "0.1.0-alpha.477",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",