enigma-memory 0.1.18 → 0.1.22

package/packages/terminal-console/outbox.mjs

@@ -0,0 +1,143 @@
+// Enigma Sovereign AI Memory — Durable Transactional Outbox Engine
+// Implements atomic persistence, per-event queueing, crash recovery, and status transitions.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import crypto from 'node:crypto';
+
+export class AutoAnchorOutbox {
+  constructor(outboxFilePath) {
+    this.filePath = resolve(outboxFilePath);
+    this.queue = [];
+    this.history = [];
+    this.load();
+  }
+
+  load() {
+    try {
+      if (existsSync(this.filePath)) {
+        const raw = readFileSync(this.filePath, 'utf8');
+        const data = JSON.parse(raw);
+        this.queue = Array.isArray(data.queue) ? data.queue : [];
+        this.history = Array.isArray(data.history) ? data.history : [];
+      }
+    } catch (err) {
+      // Quarantine corrupt file for forensic review rather than discarding
+      if (existsSync(this.filePath)) {
+        const backupPath = `${this.filePath}.corrupt.${Date.now()}`;
+        renameSync(this.filePath, backupPath);
+      }
+      this.queue = [];
+      this.history = [];
+    }
+  }
+
+  save() {
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const payload = JSON.stringify({
+      schema: 'enigma.auto_anchor_outbox.v1',
+      updated_at: new Date().toISOString(),
+      pending_count: this.queue.length,
+      queue: this.queue,
+      history: this.history.slice(-50),
+    }, null, 2);
+
+    const tempPath = `${this.filePath}.tmp.${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    writeFileSync(tempPath, payload, 'utf8');
+    renameSync(tempPath, this.filePath);
+  }
+
+  enqueue({
+    vaultId = 'default',
+    sequence = 0,
+    activeSetRoot,
+    receiptLogRoot = null,
+    authorizationHash = null,
+  }) {
+    if (!activeSetRoot) throw new Error('Cannot enqueue anchor without activeSetRoot');
+
+    const now = new Date().toISOString();
+    const item = {
+      id: `outbox_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`,
+      vaultId,
+      sequence,
+      activeSetRoot,
+      receiptLogRoot: receiptLogRoot || 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+      authorizationHash,
+      status: 'pending',
+      retries: 0,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.queue.push(item);
+    this.save();
+    return item;
+  }
+
+  peek() {
+    return this.queue.find((item) => item.status === 'pending') || null;
+  }
+
+  markProcessing(id) {
+    const item = this.queue.find((i) => i.id === id);
+    if (item) {
+      item.status = 'processing';
+      item.updatedAt = new Date().toISOString();
+      this.save();
+      return item;
+    }
+    return null;
+  }
+
+  markSubmitted(id, { signature }) {
+    const item = this.queue.find((i) => i.id === id);
+    if (item) {
+      item.status = 'submitted';
+      item.signature = signature;
+      item.submittedAt = new Date().toISOString();
+      item.updatedAt = new Date().toISOString();
+      this.save();
+      return item;
+    }
+    return null;
+  }
+
+  markAnchored(id, { signature, slot = null, cluster = 'mainnet-beta' }) {
+    const idx = this.queue.findIndex((item) => item.id === id);
+    if (idx >= 0) {
+      const item = this.queue.splice(idx, 1)[0];
+      item.status = 'anchored';
+      item.signature = signature || item.signature;
+      item.slot = slot;
+      item.cluster = cluster;
+      item.solscanUrl = `https://solscan.io/tx/${item.signature}`;
+      item.confirmedAt = new Date().toISOString();
+      this.history.push(item);
+      this.save();
+      return item;
+    }
+    return null;
+  }
+
+  markFailed(id, errorMessage) {
+    const item = this.queue.find((i) => i.id === id);
+    if (item) {
+      item.retries = (item.retries || 0) + 1;
+      item.lastError = errorMessage;
+      item.updatedAt = new Date().toISOString();
+      item.status = item.retries >= 5 ? 'failed' : 'pending';
+      this.save();
+      return item;
+    }
+    return null;
+  }
+
+  getStats() {
+    return {
+      pendingCount: this.queue.length,
+      historicalCount: this.history.length,
+      oldestPending: this.peek(),
+    };
+  }
+}