@ouro.bot/cli 0.1.0-alpha.474 → 0.1.0-alpha.476

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.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": [
+        "Native mail autonomy now counts recently submitted provider-backed sends against the rate window immediately, so Azure Communication Services deliveries cannot slip past the autonomous send limit while delivery events are still pending.",
+        "Mail autonomy coverage now locks the submitted-provider case explicitly, preventing back-to-back autonomous sends from bypassing policy before provider reconciliation arrives.",
+        "The `ouro.bot` wrapper stays version-synced for the mail autonomy rate-limit repair release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.474",
       "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,
         });

package/dist/mailroom/autonomy.js

@@ -73,9 +73,9 @@ function isRecipientAllowed(policy, recipient) {
     return policy.allowedRecipients.includes(recipient) || policy.allowedDomains.includes(recipientDomain(recipient));
 }
 function autonomousSentAt(record) {
-    if (record.status !== "sent" || record.sendMode !== "autonomous")
+    if (record.sendMode !== "autonomous")
         return null;
-    return record.sentAt ?? record.updatedAt;
+    return record.sentAt ?? record.submittedAt ?? record.acceptedAt ?? record.deliveredAt ?? record.failedAt ?? record.updatedAt;
 }
 function countRecentAutonomousSends(input) {
     const startsAt = input.nowMs - input.windowMs;

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.474",
+  "version": "0.1.0-alpha.476",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",