aegis-bridge 2.7.0 → 2.8.0

package/dist/memory-bridge.d.ts

@@ -0,0 +1,27 @@
+interface MemoryEntry {
+    value: string;
+    namespace: string;
+    key: string;
+    created_at: number;
+    updated_at: number;
+    expires_at?: number;
+}
+export declare class MemoryBridge {
+    private reaperIntervalMs;
+    private store;
+    private persistPath;
+    private reaperTimer;
+    private saveTimer;
+    constructor(persistPath?: string | null, reaperIntervalMs?: number);
+    set(key: string, value: string, ttlSeconds?: number): MemoryEntry;
+    get(key: string): MemoryEntry | null;
+    delete(key: string): boolean;
+    list(prefix?: string): MemoryEntry[];
+    resolveKeys(keys: string[]): Map<string, string>;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    private scheduleSave;
+    startReaper(): void;
+    stopReaper(): void;
+}
+export {};

package/dist/memory-bridge.js

@@ -0,0 +1,118 @@
+import { existsSync, renameSync, writeFileSync, readFileSync } from "fs";
+const KEY_REGEX = /^(.+?)\/(.+)$/;
+const MAX_KEY_LEN = 256;
+const MAX_VALUE_SIZE = 100 * 1024; // 100KB
+export class MemoryBridge {
+    reaperIntervalMs;
+    store = new Map();
+    persistPath = null;
+    reaperTimer = null;
+    saveTimer = null;
+    constructor(persistPath = null, reaperIntervalMs = 60_000) {
+        this.reaperIntervalMs = reaperIntervalMs;
+        this.persistPath = persistPath;
+    }
+    set(key, value, ttlSeconds) {
+        if (value.length > MAX_VALUE_SIZE)
+            throw new Error("Value exceeds maximum size");
+        const m = KEY_REGEX.exec(key);
+        if (!m)
+            throw new Error(`Invalid key format: must be namespace/key, got "${key}"`);
+        const [, namespace, keyName] = m;
+        if (key.length > MAX_KEY_LEN)
+            throw new Error("Key exceeds maximum length");
+        const now = Date.now();
+        const entry = {
+            value, namespace, key,
+            created_at: this.store.has(key) ? this.store.get(key).created_at : now,
+            updated_at: now,
+            expires_at: ttlSeconds ? now + ttlSeconds * 1000 : undefined,
+        };
+        this.store.set(key, entry);
+        this.scheduleSave();
+        return entry;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (entry.expires_at && Date.now() > entry.expires_at) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    delete(key) {
+        const deleted = this.store.delete(key);
+        if (deleted)
+            this.scheduleSave();
+        return deleted;
+    }
+    list(prefix) {
+        const now = Date.now();
+        const entries = [...this.store.values()].filter(e => !e.expires_at || now <= e.expires_at);
+        if (!prefix)
+            return entries;
+        return entries.filter(e => e.key.startsWith(prefix));
+    }
+    resolveKeys(keys) {
+        const result = new Map();
+        for (const k of keys) {
+            const e = this.get(k);
+            if (e)
+                result.set(k, e.value);
+        }
+        return result;
+    }
+    async load() {
+        if (!this.persistPath || !existsSync(this.persistPath))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.persistPath, "utf-8"));
+            if (Array.isArray(raw)) {
+                for (const e of raw) {
+                    if (e.key && e.value)
+                        this.store.set(e.key, e);
+                }
+            }
+        }
+        catch { /* ignore corrupt file */ }
+    }
+    async save() {
+        if (!this.persistPath)
+            return;
+        const entries = [...this.store.values()];
+        const tmp = this.persistPath + ".tmp";
+        writeFileSync(tmp, JSON.stringify(entries, null, 2));
+        renameSync(tmp, this.persistPath);
+    }
+    scheduleSave() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(async () => {
+            this.saveTimer = null;
+            await this.save();
+        }, 1000);
+    }
+    startReaper() {
+        if (this.reaperTimer)
+            return;
+        this.reaperTimer = setInterval(() => {
+            const now = Date.now();
+            for (const [k, e] of this.store) {
+                if (e.expires_at && now > e.expires_at)
+                    this.store.delete(k);
+            }
+        }, this.reaperIntervalMs);
+    }
+    stopReaper() {
+        if (this.reaperTimer) {
+            clearInterval(this.reaperTimer);
+            this.reaperTimer = null;
+        }
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aegis-bridge",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "type": "module",
   "description": "Orchestrate Claude Code sessions via API. Create, brief, monitor, refine, ship.",
   "main": "dist/server.js",