@ouro.bot/cli 0.1.0-alpha.72 → 0.1.0-alpha.720

package/dist/heart/attachments/sources/bluebubbles.js

@@ -0,0 +1,156 @@
+"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.blueBubblesAttachmentSourceAdapter = void 0;
+exports.buildBlueBubblesAttachmentRecord = buildBlueBubblesAttachmentRecord;
+exports.persistBlueBubblesAttachmentSource = persistBlueBubblesAttachmentSource;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../../nerves/runtime");
+const attachment_download_1 = require("../../../senses/bluebubbles/attachment-download");
+const config_1 = require("../../config");
+const identity_1 = require("../../identity");
+const originals_1 = require("../originals");
+const store_1 = require("../store");
+const types_1 = require("../types");
+function normalizeBlueBubblesRecord(attachment) {
+    if (attachment.source !== "bluebubbles") {
+        throw new Error(`bluebubbles adapter cannot materialize ${attachment.source} attachments`);
+    }
+    const sourceData = attachment.sourceData;
+    const guid = typeof sourceData?.guid === "string" && sourceData.guid.trim().length > 0
+        ? sourceData.guid.trim()
+        : attachment.sourceId.trim();
+    if (!guid) {
+        throw new Error("BlueBubbles attachment guid is required");
+    }
+    const localPath = typeof sourceData?.localPath === "string" && sourceData.localPath.trim().length > 0
+        ? path.resolve(sourceData.localPath)
+        : undefined;
+    return {
+        ...attachment,
+        source: "bluebubbles",
+        sourceId: guid,
+        sourceData: {
+            guid,
+            mimeType: typeof sourceData?.mimeType === "string" ? sourceData.mimeType : attachment.mimeType,
+            transferName: typeof sourceData?.transferName === "string" ? sourceData.transferName : attachment.displayName,
+            totalBytes: typeof sourceData?.totalBytes === "number" ? sourceData.totalBytes : attachment.byteCount,
+            height: typeof sourceData?.height === "number" ? sourceData.height : undefined,
+            width: typeof sourceData?.width === "number" ? sourceData.width : undefined,
+            ...(localPath ? { localPath } : {}),
+        },
+    };
+}
+function buildBlueBubblesAttachmentRecord(summary, now = Date.now(), options = {}) {
+    const guid = summary.guid?.trim();
+    if (!guid) {
+        throw new Error("BlueBubbles attachment guid is required");
+    }
+    const displayName = summary.transferName?.trim() || guid;
+    const mimeType = options.mimeType?.trim().toLowerCase() || summary.mimeType?.trim().toLowerCase() || undefined;
+    return (0, types_1.createAttachmentRecord)({
+        source: "bluebubbles",
+        sourceId: guid,
+        displayName,
+        mimeType,
+        byteCount: options.byteCount ?? summary.totalBytes,
+        sourceData: {
+            ...summary,
+            guid,
+            ...(options.localPath ? { localPath: path.resolve(options.localPath) } : {}),
+        },
+    }, now);
+}
+async function persistBlueBubblesAttachmentSource(agentName, attachment, input, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    const normalizedAttachment = normalizeBlueBubblesRecord(attachment);
+    const targetPath = (0, originals_1.originalStoragePath)(agentRoot, normalizedAttachment, input.mimeType);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, input.buffer);
+    const updated = buildBlueBubblesAttachmentRecord({
+        ...normalizedAttachment.sourceData,
+        mimeType: input.mimeType ?? normalizedAttachment.sourceData.mimeType,
+        totalBytes: input.byteCount ?? normalizedAttachment.byteCount,
+    }, normalizedAttachment.createdAt, {
+        localPath: targetPath,
+        mimeType: input.mimeType ?? normalizedAttachment.mimeType,
+        byteCount: input.byteCount ?? normalizedAttachment.byteCount,
+    });
+    updated.lastSeenAt = Date.now();
+    (0, store_1.cacheRecentAttachment)(agentName, updated, agentRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_source_persisted",
+        message: "attachment materialization updated",
+        meta: {
+            attachmentId: normalizedAttachment.id,
+            source: normalizedAttachment.source,
+            mimeType: updated.mimeType,
+        },
+    });
+    return updated;
+}
+exports.blueBubblesAttachmentSourceAdapter = {
+    source: "bluebubbles",
+    async materializeOriginal({ agentName, attachment, agentRoot }) {
+        const normalizedAttachment = normalizeBlueBubblesRecord(attachment);
+        const localPath = normalizedAttachment.sourceData.localPath?.trim();
+        if (localPath) {
+            await (0, originals_1.ensureReadableFile)(localPath);
+            return (0, originals_1.buildOriginalMaterializedAttachment)(normalizedAttachment, localPath);
+        }
+        const fallbackPath = (0, originals_1.originalStoragePath)(agentRoot, normalizedAttachment);
+        try {
+            await (0, originals_1.ensureReadableFile)(fallbackPath);
+            return (0, originals_1.buildOriginalMaterializedAttachment)(normalizedAttachment, fallbackPath);
+        }
+        catch {
+            const config = (0, config_1.getBlueBubblesConfig)();
+            const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
+            const downloaded = await (0, attachment_download_1.downloadBlueBubblesAttachment)(normalizedAttachment.sourceData, config, channelConfig);
+            const updated = await persistBlueBubblesAttachmentSource(agentName, normalizedAttachment, {
+                buffer: downloaded.buffer,
+                mimeType: downloaded.contentType,
+                byteCount: downloaded.buffer.length,
+            }, agentRoot);
+            const persistedPath = updated.sourceData.localPath;
+            /* v8 ignore next -- persistBlueBubblesAttachmentSource always writes localPath before returning @preserve */
+            if (!persistedPath) {
+                throw new Error("BlueBubbles attachment persistence did not yield a local path");
+            }
+            return (0, originals_1.buildOriginalMaterializedAttachment)(updated, persistedPath, downloaded.contentType ?? updated.mimeType, downloaded.buffer.length);
+        }
+    },
+};

package/dist/heart/attachments/sources/cli-local-file.js

@@ -0,0 +1,78 @@
+"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.cliLocalFileAttachmentSourceAdapter = void 0;
+exports.buildCliLocalFileAttachmentRecord = buildCliLocalFileAttachmentRecord;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const originals_1 = require("../originals");
+const types_1 = require("../types");
+function stableCliLocalFileId(filePath) {
+    return (0, node_crypto_1.createHash)("sha1").update(path.resolve(filePath)).digest("hex").slice(0, 16);
+}
+function requireCliLocalFilePath(attachment) {
+    if (attachment.source !== "cli-local-file") {
+        throw new Error(`cli-local-file adapter cannot materialize ${attachment.source} attachments`);
+    }
+    const rawPath = attachment.sourceData?.path;
+    if (typeof rawPath !== "string" || rawPath.trim().length === 0) {
+        throw new Error("CLI local attachment path is required");
+    }
+    return path.resolve(rawPath);
+}
+function buildCliLocalFileAttachmentRecord(input, now = Date.now()) {
+    const resolvedPath = path.resolve(input.path);
+    const displayName = input.displayName?.trim() || path.basename(resolvedPath);
+    const mimeType = input.mimeType?.trim().toLowerCase() || undefined;
+    const stableId = stableCliLocalFileId(resolvedPath);
+    return (0, types_1.createAttachmentRecord)({
+        source: "cli-local-file",
+        sourceId: stableId,
+        displayName,
+        mimeType,
+        byteCount: input.byteCount,
+        sourceData: {
+            path: resolvedPath,
+        },
+    }, now);
+}
+exports.cliLocalFileAttachmentSourceAdapter = {
+    source: "cli-local-file",
+    async materializeOriginal({ attachment }) {
+        const filePath = requireCliLocalFilePath(attachment);
+        await (0, originals_1.ensureReadableFile)(filePath);
+        return (0, originals_1.buildOriginalMaterializedAttachment)(attachment, filePath);
+    },
+};

package/dist/heart/attachments/sources/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttachmentSourceAdapter = getAttachmentSourceAdapter;
+const bluebubbles_1 = require("./bluebubbles");
+const cli_local_file_1 = require("./cli-local-file");
+const ATTACHMENT_SOURCE_ADAPTERS = {
+    bluebubbles: bluebubbles_1.blueBubblesAttachmentSourceAdapter,
+    "cli-local-file": cli_local_file_1.cliLocalFileAttachmentSourceAdapter,
+};
+function getAttachmentSourceAdapter(source) {
+    const adapter = ATTACHMENT_SOURCE_ADAPTERS[source];
+    if (!adapter) {
+        throw new Error(`No attachment source adapter registered for source: ${source}`);
+    }
+    return adapter;
+}

package/dist/heart/attachments/store.js

@@ -0,0 +1,103 @@
+"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.MAX_RECENT_ATTACHMENTS = void 0;
+exports.getRecentAttachmentsPath = getRecentAttachmentsPath;
+exports.readRecentAttachments = readRecentAttachments;
+exports.cacheRecentAttachment = cacheRecentAttachment;
+exports.getRecentAttachment = getRecentAttachment;
+exports.listRecentAttachments = listRecentAttachments;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+exports.MAX_RECENT_ATTACHMENTS = 100;
+function getRecentAttachmentsPath(agentName, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    return path.join(agentRoot, "state", "attachments", "recent.json");
+}
+function readRecentAttachments(agentName, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    const targetPath = getRecentAttachmentsPath(agentName, agentRoot);
+    if (!fs.existsSync(targetPath)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(targetPath, "utf-8"));
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.attachment_store_read_error",
+            message: "failed to read recent attachments store",
+            meta: {
+                path: targetPath,
+                reason: String(error),
+            },
+        });
+        return [];
+    }
+}
+function writeRecentAttachments(agentName, agentRoot, attachments) {
+    const targetPath = getRecentAttachmentsPath(agentName, agentRoot);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, JSON.stringify(attachments, null, 2), "utf-8");
+}
+function cacheRecentAttachment(agentName, attachment, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    const deduped = readRecentAttachments(agentName, agentRoot).filter((entry) => entry.id !== attachment.id);
+    const updated = [attachment, ...deduped]
+        .sort((a, b) => b.lastSeenAt - a.lastSeenAt)
+        .slice(0, exports.MAX_RECENT_ATTACHMENTS);
+    writeRecentAttachments(agentName, agentRoot, updated);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_store_updated",
+        message: "recent attachment stored",
+        meta: { attachmentId: attachment.id, source: attachment.source, kind: attachment.kind },
+    });
+    return attachment;
+}
+function getRecentAttachment(agentName, attachmentId, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    return readRecentAttachments(agentName, agentRoot).find((entry) => entry.id === attachmentId) ?? null;
+}
+function listRecentAttachments(agentName, options = {}, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    const limit = Math.max(1, options.limit ?? exports.MAX_RECENT_ATTACHMENTS);
+    return readRecentAttachments(agentName, agentRoot)
+        .filter((entry) => !options.kind || entry.kind === options.kind)
+        .slice(0, limit);
+}

package/dist/heart/attachments/types.js

@@ -0,0 +1,93 @@
+"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.createAttachmentRecord = createAttachmentRecord;
+exports.buildAttachmentId = buildAttachmentId;
+exports.classifyAttachmentKind = classifyAttachmentKind;
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+function createAttachmentRecord(input, now = Date.now()) {
+    const record = {
+        id: buildAttachmentId(input.source, input.sourceId),
+        source: input.source,
+        sourceId: input.sourceId,
+        kind: classifyAttachmentKind(input.mimeType, input.displayName),
+        displayName: input.displayName,
+        mimeType: input.mimeType,
+        byteCount: input.byteCount,
+        createdAt: now,
+        lastSeenAt: now,
+        sourceData: input.sourceData,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_record_built",
+        message: "attachment record helper invoked",
+        meta: {
+            source: record.source,
+            kind: record.kind,
+        },
+    });
+    return record;
+}
+function buildAttachmentId(source, stableId) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.attachment_id_built",
+        message: "attachment record helper invoked",
+        meta: { source },
+    });
+    return `attachment:${source}:${stableId}`;
+}
+function classifyAttachmentKind(mimeType, displayName) {
+    const normalizedMime = mimeType?.trim().toLowerCase() ?? "";
+    const extension = path.extname(displayName ?? "").toLowerCase();
+    if (normalizedMime.startsWith("image/"))
+        return "image";
+    if (normalizedMime.startsWith("audio/"))
+        return "audio";
+    if (normalizedMime.startsWith("text/")
+        || normalizedMime === "application/pdf"
+        || extension === ".pdf"
+        || extension === ".txt"
+        || extension === ".md"
+        || extension === ".doc"
+        || extension === ".docx") {
+        return "document";
+    }
+    if (!normalizedMime && !displayName)
+        return "unknown";
+    return "binary";
+}