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

package/dist/heart/outlook/readers/mail.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMailView = readMailView;
+exports.readMailMessageView = readMailMessageView;
+const runtime_1 = require("../../../nerves/runtime");
+const file_store_1 = require("../../../mailroom/file-store");
+const reader_1 = require("../../../mailroom/reader");
+const OUTLOOK_MAIL_LIST_LIMIT = 50;
+const OUTLOOK_MAIL_COUNT_LIMIT = 500;
+const OUTLOOK_MAIL_BODY_LIMIT = 12_000;
+function emptyFolders() {
+    return [
+        { id: "imbox", label: "Imbox", count: 0 },
+        { id: "screener", label: "Screener", count: 0 },
+        { id: "delegated", label: "Delegated", count: 0 },
+        { id: "native", label: "Native", count: 0 },
+    ];
+}
+function unavailableMailView(agentName, status, error) {
+    return {
+        status,
+        agentName,
+        mailboxAddress: null,
+        generatedAt: new Date().toISOString(),
+        store: null,
+        folders: emptyFolders(),
+        messages: [],
+        accessLog: [],
+        error,
+    };
+}
+function unavailableMessageView(agentName, status, error) {
+    return {
+        status,
+        agentName,
+        mailboxAddress: null,
+        generatedAt: new Date().toISOString(),
+        message: null,
+        accessLog: [],
+        error,
+    };
+}
+function mailSummary(message) {
+    return {
+        id: message.id,
+        subject: message.private.subject,
+        from: message.private.from,
+        to: message.private.to,
+        cc: message.private.cc,
+        date: message.private.date ?? null,
+        receivedAt: message.receivedAt,
+        snippet: message.private.snippet,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ownerEmail: message.ownerEmail ?? null,
+        source: message.source ?? null,
+        recipient: message.recipient,
+        attachmentCount: message.private.attachments.length,
+        untrustedContentWarning: message.private.untrustedContentWarning,
+    };
+}
+function buildFolders(messages) {
+    const folders = [
+        { id: "imbox", label: "Imbox", count: messages.filter((message) => message.placement === "imbox").length },
+        { id: "screener", label: "Screener", count: messages.filter((message) => message.placement === "screener").length },
+        { id: "delegated", label: "Delegated", count: messages.filter((message) => message.compartmentKind === "delegated").length },
+        { id: "native", label: "Native", count: messages.filter((message) => message.compartmentKind === "native").length },
+    ];
+    const sourceCounts = new Map();
+    for (const message of messages) {
+        if (!message.source)
+            continue;
+        sourceCounts.set(message.source, (sourceCounts.get(message.source) ?? 0) + 1);
+    }
+    for (const [source, count] of [...sourceCounts.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        folders.push({ id: `source:${source}`, label: source.toUpperCase(), count });
+    }
+    return folders;
+}
+function accessEntries(entries) {
+    return entries
+        .slice()
+        .sort((left, right) => right.accessedAt.localeCompare(left.accessedAt))
+        .slice(0, 20)
+        .map((entry) => ({
+        id: entry.id,
+        messageId: entry.messageId ?? null,
+        threadId: entry.threadId ?? null,
+        tool: entry.tool,
+        reason: entry.reason,
+        accessedAt: entry.accessedAt,
+    }));
+}
+function emitMailRead(agentName, mode, status) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_mail_read",
+        message: "reading Outlook mail surface",
+        meta: { agentName, mode, status },
+    });
+}
+function statusFromReaderFailure(reason) {
+    return reason;
+}
+async function readMailView(agentName) {
+    const resolved = (0, reader_1.resolveMailroomReader)(agentName);
+    if (!resolved.ok) {
+        const status = statusFromReaderFailure(resolved.reason);
+        emitMailRead(agentName, "list", status);
+        return unavailableMailView(agentName, status, resolved.error);
+    }
+    try {
+        const stored = await resolved.store.listMessages({ agentId: agentName, limit: OUTLOOK_MAIL_COUNT_LIMIT });
+        const decrypted = (0, file_store_1.decryptMessages)(stored, resolved.config.privateKeys);
+        const summaries = decrypted.map(mailSummary);
+        await resolved.store.recordAccess({
+            agentId: agentName,
+            tool: "outlook_mail_list",
+            reason: "outlook read-only mailbox",
+        });
+        const accessLog = accessEntries(await resolved.store.listAccessLog(agentName));
+        emitMailRead(agentName, "list", "ready");
+        return {
+            status: "ready",
+            agentName,
+            mailboxAddress: resolved.config.mailboxAddress,
+            generatedAt: new Date().toISOString(),
+            store: {
+                kind: resolved.storeKind,
+                label: resolved.storeLabel,
+            },
+            folders: buildFolders(summaries),
+            messages: summaries.slice(0, OUTLOOK_MAIL_LIST_LIMIT),
+            accessLog,
+            error: null,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMailRead(agentName, "list", "error");
+        return unavailableMailView(agentName, "error", message);
+    }
+}
+async function readMailMessageView(agentName, messageId) {
+    const resolved = (0, reader_1.resolveMailroomReader)(agentName);
+    if (!resolved.ok) {
+        const status = statusFromReaderFailure(resolved.reason);
+        emitMailRead(agentName, "message", status);
+        return unavailableMessageView(agentName, status, resolved.error);
+    }
+    try {
+        const stored = await resolved.store.getMessage(messageId);
+        if (!stored || stored.agentId !== agentName) {
+            emitMailRead(agentName, "message", "not-found");
+            return {
+                status: "not-found",
+                agentName,
+                mailboxAddress: resolved.config.mailboxAddress,
+                generatedAt: new Date().toISOString(),
+                message: null,
+                accessLog: accessEntries(await resolved.store.listAccessLog(agentName)),
+                error: `No visible mail message found for ${messageId}.`,
+            };
+        }
+        const decrypted = (0, file_store_1.decryptMessages)([stored], resolved.config.privateKeys)[0];
+        const access = await resolved.store.recordAccess({
+            agentId: agentName,
+            messageId,
+            tool: "outlook_mail_message",
+            reason: "outlook read-only message body",
+        });
+        const body = decrypted.private.text.length > OUTLOOK_MAIL_BODY_LIMIT
+            ? decrypted.private.text.slice(0, OUTLOOK_MAIL_BODY_LIMIT)
+            : decrypted.private.text;
+        const detail = {
+            ...mailSummary(decrypted),
+            text: body,
+            htmlAvailable: typeof decrypted.private.html === "string" && decrypted.private.html.length > 0,
+            bodyTruncated: decrypted.private.text.length > OUTLOOK_MAIL_BODY_LIMIT,
+            attachments: decrypted.private.attachments,
+            access: {
+                tool: access.tool,
+                reason: access.reason,
+                accessedAt: access.accessedAt,
+            },
+        };
+        emitMailRead(agentName, "message", "ready");
+        return {
+            status: "ready",
+            agentName,
+            mailboxAddress: resolved.config.mailboxAddress,
+            generatedAt: new Date().toISOString(),
+            message: detail,
+            accessLog: accessEntries(await resolved.store.listAccessLog(agentName)),
+            error: null,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitMailRead(agentName, "message", "error");
+        return unavailableMessageView(agentName, "error", message);
+    }
+}

package/dist/heart/sense-truth.js

@@ -7,12 +7,16 @@ const SENSES = [
     { sense: "cli", label: "CLI", daemonManaged: false },
     { sense: "teams", label: "Teams", daemonManaged: true },
     { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+    { sense: "mail", label: "Mail", daemonManaged: true },
 ];
 function configuredSenses(senses) {
-    return senses ?? {
-        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
-        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
-        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    const configured = senses ?? {};
+    return {
+        ...configured,
+        cli: configured.cli ?? { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: configured.teams ?? { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: configured.bluebubbles ?? { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+        mail: configured.mail ?? { ...identity_1.DEFAULT_AGENT_SENSES.mail },
     };
 }
 function resolveStatus(enabled, daemonManaged, runtimeInfo) {

package/dist/heart/turn-context.js

@@ -141,18 +141,24 @@ function hasTextField(record, key) {
 }
 function readSenseStatusLines() {
     const config = (0, identity_1.loadAgentConfig)();
-    const senses = config.senses ?? {
-        cli: { enabled: true },
-        teams: { enabled: false },
-        bluebubbles: { enabled: false },
+    const configuredSenses = config.senses ?? {};
+    const senses = {
+        ...configuredSenses,
+        cli: configuredSenses.cli ?? { enabled: true },
+        teams: configuredSenses.teams ?? { enabled: false },
+        bluebubbles: configuredSenses.bluebubbles ?? { enabled: false },
+        mail: configuredSenses.mail ?? { enabled: false },
     };
     const payload = (0, config_1.loadConfig)();
     const teams = payload.teams;
     const bluebubbles = payload.bluebubbles;
+    const mailroom = payload.mailroom;
+    const privateKeys = mailroom?.privateKeys;
     const configured = {
         cli: true,
         teams: hasTextField(teams, "clientId") && hasTextField(teams, "clientSecret") && hasTextField(teams, "tenantId"),
         bluebubbles: hasTextField(bluebubbles, "serverUrl") && hasTextField(bluebubbles, "password"),
+        mail: hasTextField(mailroom, "mailboxAddress") && !!privateKeys && typeof privateKeys === "object" && !Array.isArray(privateKeys),
     };
     const rows = [
         { label: "CLI", status: "interactive" },
@@ -164,6 +170,10 @@ function readSenseStatusLines() {
             label: "BlueBubbles",
             status: !senses.bluebubbles.enabled ? "disabled" : configured.bluebubbles ? "ready" : "not_attached",
         },
+        {
+            label: "Mail",
+            status: !senses.mail.enabled ? "disabled" : configured.mail ? "ready" : "needs_config",
+        },
     ];
     return rows.map((row) => `- ${row.label}: ${row.status}`);
 }

package/dist/mailroom/blob-store.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureBlobMailroomStore = void 0;
+exports.decryptBlobMessages = decryptBlobMessages;
+const runtime_1 = require("../nerves/runtime");
+const core_1 = require("./core");
+function compareNewestFirst(left, right) {
+    return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
+}
+function blobText(value) {
+    return Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+async function downloadJson(blob) {
+    if (!await blob.exists())
+        return null;
+    return JSON.parse((await blob.downloadToBuffer()).toString("utf-8"));
+}
+class AzureBlobMailroomStore {
+    serviceClient;
+    containerName;
+    containerReady = null;
+    constructor(options) {
+        this.serviceClient = options.serviceClient;
+        this.containerName = options.containerName;
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_store_init",
+            message: "azure blob mailroom store initialized",
+            meta: { containerName: this.containerName },
+        });
+    }
+    get container() {
+        return this.serviceClient.getContainerClient(this.containerName);
+    }
+    async ensureContainer() {
+        if (!this.containerReady) {
+            this.containerReady = this.container.createIfNotExists().then(() => undefined);
+        }
+        await this.containerReady;
+    }
+    messageBlob(id) {
+        return this.container.getBlockBlobClient(`messages/${id}.json`);
+    }
+    rawBlob(objectName) {
+        return this.container.getBlockBlobClient(objectName);
+    }
+    accessLogBlob(agentId) {
+        return this.container.getBlockBlobClient(`access-log/${agentId}.jsonl`);
+    }
+    async putRawMessage(input) {
+        await this.ensureContainer();
+        const { message, rawPayload } = await (0, core_1.buildStoredMailMessage)(input);
+        const existing = await downloadJson(this.messageBlob(message.id));
+        if (existing) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_blob_store_dedupe",
+                message: "azure blob mailroom store deduped existing message",
+                meta: { id: message.id, agentId: message.agentId },
+            });
+            return { created: false, message: existing };
+        }
+        await this.rawBlob(message.rawObject).uploadData(blobText(rawPayload));
+        await this.messageBlob(message.id).uploadData(blobText(message));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_store_message_written",
+            message: "azure blob mailroom store wrote message",
+            meta: { id: message.id, agentId: message.agentId },
+        });
+        return { created: true, message };
+    }
+    async getMessage(id) {
+        await this.ensureContainer();
+        const message = await downloadJson(this.messageBlob(id));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_store_message_read",
+            message: "azure blob mailroom store read message",
+            meta: { id, found: message !== null },
+        });
+        return message;
+    }
+    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);
+        }
+        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 },
+        });
+        return filtered;
+    }
+    async readRawPayload(objectName) {
+        await this.ensureContainer();
+        const payload = await downloadJson(this.rawBlob(objectName));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_store_raw_read",
+            message: "azure blob mailroom store read raw payload",
+            meta: { objectName, found: payload !== null },
+        });
+        return payload;
+    }
+    async recordAccess(entry) {
+        await this.ensureContainer();
+        const complete = {
+            ...entry,
+            id: `access_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            accessedAt: new Date().toISOString(),
+        };
+        const blob = this.accessLogBlob(entry.agentId);
+        const existing = await downloadJson(blob).catch(() => null);
+        const entries = Array.isArray(existing) ? existing : [];
+        entries.push(complete);
+        await blob.uploadData(blobText(entries));
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_access_recorded",
+            message: "azure blob mail access recorded",
+            meta: { agentId: entry.agentId, messageId: entry.messageId ?? null, tool: entry.tool },
+        });
+        return complete;
+    }
+    async listAccessLog(agentId) {
+        await this.ensureContainer();
+        const entries = await downloadJson(this.accessLogBlob(agentId));
+        const safeEntries = Array.isArray(entries) ? entries : [];
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.mail_blob_access_log_listed",
+            message: "azure blob mail access log listed",
+            meta: { agentId, count: safeEntries.length },
+        });
+        return safeEntries;
+    }
+}
+exports.AzureBlobMailroomStore = AzureBlobMailroomStore;
+function decryptBlobMessages(messages, privateKeys) {
+    return messages.map((message) => (0, core_1.decryptStoredMailMessage)(message, privateKeys));
+}