@ouro.bot/cli 0.1.0-alpha.454 → 0.1.0-alpha.456

package/dist/senses/mail.js

@@ -0,0 +1,224 @@
+"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.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 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 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 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);
+    }
+    if (!resolved.config.registryPath) {
+        throw new Error(`missing mailroom.registryPath for ${options.agentName}; run 'ouro connect mail --agent ${options.agentName}' again`);
+    }
+    const registry = readRegistry(resolved.config.registryPath);
+    const host = resolved.config.host ?? "127.0.0.1";
+    const ingress = (options.startIngress ?? smtp_ingress_1.startMailroomIngress)({
+        registry,
+        store: resolved.store,
+        smtpPort: validPort(resolved.config.smtpPort),
+        httpPort: validPort(resolved.config.httpPort),
+        host,
+    });
+    await Promise.all([
+        waitForListening(ingress.smtp),
+        waitForListening(ingress.health),
+    ]);
+    const runtimePath = runtimeStatePath(options.agentName);
+    const attentionPath = attentionStatePath(options.agentName);
+    let lastScanAt = null;
+    let lastQueuedCount = 0;
+    const scan = async () => {
+        try {
+            const scanStartedAt = new Date(now()).toISOString();
+            const result = await (0, attention_1.scanMailScreenerAttention)({
+                agentName: options.agentName,
+                store: resolved.store,
+                pendingDir: (0, pending_1.getInnerDialogPendingDir)(options.agentName),
+                statePath: attentionPath,
+                now,
+            });
+            lastScanAt = scanStartedAt;
+            lastQueuedCount = result.queued.length;
+            writeRuntimeState(runtimePath, {
+                schemaVersion: 1,
+                agentName: options.agentName,
+                status: "running",
+                mailboxAddress: resolved.config.mailboxAddress,
+                smtpPort: serverPort(ingress.smtp),
+                httpPort: serverPort(ingress.health),
+                host,
+                storeKind: resolved.storeKind,
+                storeLabel: resolved.storeLabel,
+                lastScanAt,
+                lastQueuedCount,
+                updatedAt: new Date(now()).toISOString(),
+            });
+        }
+        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) },
+            });
+        }
+    };
+    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: serverPort(ingress.smtp),
+            httpPort: serverPort(ingress.health),
+            intervalMs,
+        },
+    });
+    return {
+        runtimeStatePath: runtimePath,
+        attentionStatePath: attentionPath,
+        smtpPort: serverPort(ingress.smtp),
+        httpPort: serverPort(ingress.health),
+        async stop() {
+            ;
+            (options.clearIntervalFn ?? ((activeTimer) => clearInterval(activeTimer)))(timer);
+            await Promise.all([
+                closeServer(ingress.smtp),
+                closeServer(ingress.health),
+            ]);
+            writeRuntimeState(runtimePath, {
+                schemaVersion: 1,
+                agentName: options.agentName,
+                status: "stopped",
+                mailboxAddress: resolved.config.mailboxAddress,
+                smtpPort: serverPort(ingress.smtp),
+                httpPort: serverPort(ingress.health),
+                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 },
+            });
+        },
+    };
+}

package/package.json

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