@ouro.bot/cli 0.1.0-alpha.56 → 0.1.0-alpha.560

package/dist/senses/mail.js

@@ -0,0 +1,379 @@
+"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.scanMailImportDiscoveryAttention = scanMailImportDiscoveryAttention;
+exports.startMailSenseApp = startMailSenseApp;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../heart/identity");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const pending_1 = require("../mind/pending");
+const socket_client_1 = require("../heart/daemon/socket-client");
+const background_operations_1 = require("../heart/background-operations");
+const mail_import_discovery_1 = require("../heart/mail-import-discovery");
+const attention_1 = require("../mailroom/attention");
+const reader_1 = require("../mailroom/reader");
+const smtp_ingress_1 = require("../mailroom/smtp-ingress");
+function readRegistry(registryPath) {
+    return JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+}
+function validPort(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 65535 ? value : 0;
+}
+function serverAddress(server) {
+    const direct = server;
+    if (typeof direct.address === "function")
+        return direct.address();
+    const wrapped = server;
+    if (typeof wrapped.server?.address === "function")
+        return wrapped.server.address();
+    return null;
+}
+function serverPort(server) {
+    const address = serverAddress(server);
+    if (!address || typeof address !== "object")
+        return null;
+    return typeof address.port === "number" ? address.port : null;
+}
+function listeningServer(server) {
+    const wrapped = server;
+    if (typeof wrapped.server?.once === "function")
+        return wrapped.server;
+    const direct = server;
+    return typeof direct.once === "function" ? direct : null;
+}
+function waitForListening(server) {
+    if (serverAddress(server))
+        return Promise.resolve();
+    const listening = listeningServer(server);
+    if (!listening)
+        return new Promise((resolve) => setImmediate(resolve));
+    if (listening.listening)
+        return Promise.resolve();
+    return new Promise((resolve) => listening.once?.("listening", resolve));
+}
+function runtimeStatePath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "mail", "runtime.json");
+}
+function attentionStatePath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "mail", "attention.json");
+}
+function importDiscoveryStatePath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "mail", "import-discovery.json");
+}
+function writeRuntimeState(filePath, state) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_sense_runtime_state_written",
+        message: "mail sense runtime state written",
+        meta: { agentName: state.agentName, status: state.status, lastQueuedCount: state.lastQueuedCount },
+    });
+}
+function emptyImportDiscoveryState(updatedAt) {
+    return {
+        schemaVersion: 1,
+        lastNotifiedFingerprint: null,
+        updatedAt,
+    };
+}
+function readImportDiscoveryState(filePath, updatedAt) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return {
+            schemaVersion: 1,
+            lastNotifiedFingerprint: typeof parsed.lastNotifiedFingerprint === "string" && parsed.lastNotifiedFingerprint.trim().length > 0
+                ? parsed.lastNotifiedFingerprint
+                : null,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : updatedAt,
+        };
+    }
+    catch {
+        return emptyImportDiscoveryState(updatedAt);
+    }
+}
+function writeImportDiscoveryState(filePath, state) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function candidateDescriptors(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry))
+        .map((entry) => ({
+        path: typeof entry.path === "string" ? entry.path : "",
+        originKind: typeof entry.originKind === "string" ? entry.originKind : undefined,
+        originLabel: typeof entry.originLabel === "string" ? entry.originLabel : undefined,
+    }))
+        .filter((entry) => entry.path.trim().length > 0);
+}
+function renderImportDiscoveryContent(candidatePaths, descriptors) {
+    const renderedCandidates = descriptors.length > 0
+        ? descriptors.map((descriptor) => `- [${descriptor.originLabel ?? descriptor.originKind ?? "filesystem"}] ${descriptor.path}`)
+        : candidatePaths.map((candidatePath) => `- ${candidatePath}`);
+    return [
+        "[Mail Import Ready]",
+        "A local MBOX archive is ready for delegated-mail backfill.",
+        "This may live in a worktree-local Playwright sandbox rather than ~/Downloads.",
+        "",
+        "recent candidates:",
+        ...renderedCandidates,
+        "",
+        "If this matches an expected mailbox backfill, run `ouro mail import-mbox --discover --owner-email <email> --source hey --agent <agent>` first so Ouro can pick the matching archive or report ambiguity.",
+    ].join("\n");
+}
+async function scanMailImportDiscoveryAttention(input) {
+    const nowMs = input.now?.() ?? Date.now();
+    const updatedAt = new Date(nowMs).toISOString();
+    const statePath = input.statePath ?? importDiscoveryStatePath(input.agentName);
+    const pendingDir = input.pendingDir ?? (0, pending_1.getInnerDialogPendingDir)(input.agentName);
+    const state = readImportDiscoveryState(statePath, updatedAt);
+    const existingOperations = (0, background_operations_1.listBackgroundOperations)({
+        agentName: input.agentName,
+        agentRoot: (0, identity_1.getAgentRoot)(input.agentName),
+        limit: 10,
+    });
+    const discovered = (0, mail_import_discovery_1.listAmbientMailImportOperations)({
+        agentName: input.agentName,
+        agentRoot: (0, identity_1.getAgentRoot)(input.agentName),
+        existingOperations,
+        repoRoot: (0, identity_1.getRepoRoot)(),
+        homeDir: process.env.HOME,
+        nowMs,
+    })[0] ?? null;
+    const fingerprint = typeof discovered?.spec?.fingerprint === "string" && discovered.spec.fingerprint.trim().length > 0
+        ? discovered.spec.fingerprint
+        : null;
+    const candidatePaths = stringArray(discovered?.spec?.candidatePaths);
+    const descriptors = candidateDescriptors(discovered?.spec?.candidateDescriptors);
+    const shouldQueue = Boolean(discovered && fingerprint && fingerprint !== state.lastNotifiedFingerprint);
+    if (shouldQueue) {
+        (0, pending_1.queuePendingMessage)(pendingDir, {
+            from: "mailroom",
+            friendId: "self",
+            channel: "mail",
+            key: "import-ready",
+            content: renderImportDiscoveryContent(candidatePaths, descriptors),
+            timestamp: nowMs,
+            mode: "reflect",
+        });
+        await (0, socket_client_1.requestInnerWake)(input.agentName).catch(() => undefined);
+    }
+    writeImportDiscoveryState(statePath, {
+        schemaVersion: 1,
+        lastNotifiedFingerprint: shouldQueue ? fingerprint : state.lastNotifiedFingerprint,
+        updatedAt,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_import_discovery_scanned",
+        message: "mail import discovery scanned",
+        meta: {
+            agentName: input.agentName,
+            queued: shouldQueue,
+            candidateCount: candidatePaths.length,
+            fingerprint,
+        },
+    });
+    return {
+        queued: shouldQueue,
+        fingerprint,
+        candidatePaths,
+    };
+}
+function closeServer(server) {
+    return new Promise((resolve) => {
+        server.close(resolve);
+    });
+}
+async function startMailSenseApp(options) {
+    const now = options.now ?? (() => Date.now());
+    /* v8 ignore next -- production wiring uses the default vault refresh; tests inject a deterministic refresh. @preserve */
+    const refreshRuntime = options.refreshRuntime ?? runtime_credentials_1.refreshRuntimeCredentialConfig;
+    await refreshRuntime(options.agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    const resolved = options.resolveReader
+        ? options.resolveReader(options.agentName)
+        : (0, reader_1.resolveMailroomReader)(options.agentName);
+    if (!resolved.ok) {
+        throw new Error(resolved.error);
+    }
+    const hostedReaderOnly = resolved.storeKind === "azure-blob" && !resolved.config.registryPath;
+    if (!resolved.config.registryPath && !hostedReaderOnly) {
+        throw new Error(`missing mailroom.registryPath for ${options.agentName}; agent-runnable repair: 'ouro connect mail --agent ${options.agentName}'`);
+    }
+    const host = resolved.config.host ?? "127.0.0.1";
+    const ingress = hostedReaderOnly
+        ? null
+        : (options.startIngress ?? smtp_ingress_1.startMailroomIngress)({
+            registry: readRegistry(resolved.config.registryPath),
+            store: resolved.store,
+            smtpPort: validPort(resolved.config.smtpPort),
+            httpPort: validPort(resolved.config.httpPort),
+            host,
+        });
+    if (ingress) {
+        await Promise.all([
+            waitForListening(ingress.smtp),
+            waitForListening(ingress.health),
+        ]);
+    }
+    const activeSmtpPort = () => ingress ? serverPort(ingress.smtp) : null;
+    const activeHttpPort = () => ingress ? serverPort(ingress.health) : null;
+    const runtimePath = runtimeStatePath(options.agentName);
+    const attentionPath = attentionStatePath(options.agentName);
+    const importDiscoveryPath = importDiscoveryStatePath(options.agentName);
+    let lastScanAt = null;
+    let lastQueuedCount = 0;
+    const scan = async () => {
+        const scanStartedAt = new Date(now()).toISOString();
+        let queuedCount = 0;
+        try {
+            const screener = await (0, attention_1.scanMailScreenerAttention)({
+                agentName: options.agentName,
+                store: resolved.store,
+                pendingDir: (0, pending_1.getInnerDialogPendingDir)(options.agentName),
+                statePath: attentionPath,
+                now,
+            });
+            queuedCount += screener.queued.length;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.mail_sense_scan_error",
+                message: "mail sense attention scan failed",
+                meta: { agentName: options.agentName, error: error instanceof Error ? error.message : String(error) },
+            });
+        }
+        try {
+            const importDiscovery = await scanMailImportDiscoveryAttention({
+                agentName: options.agentName,
+                pendingDir: (0, pending_1.getInnerDialogPendingDir)(options.agentName),
+                statePath: importDiscoveryPath,
+                now,
+            });
+            if (importDiscovery.queued) {
+                queuedCount += 1;
+            }
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.mail_import_discovery_scan_error",
+                message: "mail import discovery scan failed",
+                meta: { agentName: options.agentName, error: error instanceof Error ? error.message : String(error) },
+            });
+        }
+        lastScanAt = scanStartedAt;
+        lastQueuedCount = queuedCount;
+        writeRuntimeState(runtimePath, {
+            schemaVersion: 1,
+            agentName: options.agentName,
+            status: "running",
+            mailboxAddress: resolved.config.mailboxAddress,
+            smtpPort: activeSmtpPort(),
+            httpPort: activeHttpPort(),
+            host,
+            storeKind: resolved.storeKind,
+            storeLabel: resolved.storeLabel,
+            lastScanAt,
+            lastQueuedCount,
+            updatedAt: new Date(now()).toISOString(),
+        });
+    };
+    await scan();
+    const intervalMs = Math.max(5_000, resolved.config.attentionIntervalMs ?? 30_000);
+    const timer = (options.setIntervalFn ?? ((callback, ms) => setInterval(callback, ms)))(() => {
+        void scan();
+    }, intervalMs);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_sense_started",
+        message: "mail sense started",
+        meta: {
+            agentName: options.agentName,
+            mailboxAddress: resolved.config.mailboxAddress,
+            smtpPort: activeSmtpPort(),
+            httpPort: activeHttpPort(),
+            intervalMs,
+        },
+    });
+    return {
+        runtimeStatePath: runtimePath,
+        attentionStatePath: attentionPath,
+        smtpPort: activeSmtpPort(),
+        httpPort: activeHttpPort(),
+        async stop() {
+            ;
+            (options.clearIntervalFn ?? ((activeTimer) => clearInterval(activeTimer)))(timer);
+            if (ingress) {
+                await Promise.all([
+                    closeServer(ingress.smtp),
+                    closeServer(ingress.health),
+                ]);
+            }
+            writeRuntimeState(runtimePath, {
+                schemaVersion: 1,
+                agentName: options.agentName,
+                status: "stopped",
+                mailboxAddress: resolved.config.mailboxAddress,
+                smtpPort: activeSmtpPort(),
+                httpPort: activeHttpPort(),
+                host,
+                storeKind: resolved.storeKind,
+                storeLabel: resolved.storeLabel,
+                lastScanAt,
+                lastQueuedCount,
+                updatedAt: new Date(now()).toISOString(),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.mail_sense_stopped",
+                message: "mail sense stopped",
+                meta: { agentName: options.agentName },
+            });
+        },
+    };
+}