aegis-bridge 2.7.0 → 2.8.1

package/dist/api-error-envelope.d.ts

@@ -0,0 +1,15 @@
+export interface ApiErrorEnvelope {
+    code: string;
+    message: string;
+    details?: unknown;
+    requestId: string;
+    error: string;
+}
+interface NormalizeApiErrorInput {
+    payload: unknown;
+    statusCode: number;
+    requestId: string;
+    contentType?: string;
+}
+export declare function normalizeApiErrorPayload(input: NormalizeApiErrorInput): unknown;
+export {};

package/dist/api-error-envelope.js

@@ -0,0 +1,80 @@
+function defaultErrorMessage(statusCode) {
+    if (statusCode >= 500)
+        return 'Internal server error';
+    if (statusCode === 404)
+        return 'Not found';
+    if (statusCode === 401)
+        return 'Unauthorized';
+    if (statusCode === 403)
+        return 'Forbidden';
+    if (statusCode === 429)
+        return 'Rate limit exceeded';
+    return 'Request failed';
+}
+function mapStatusToCode(statusCode) {
+    if (statusCode === 400)
+        return 'VALIDATION_ERROR';
+    if (statusCode === 401)
+        return 'UNAUTHORIZED';
+    if (statusCode === 403)
+        return 'FORBIDDEN';
+    if (statusCode === 404)
+        return 'NOT_FOUND';
+    if (statusCode === 409)
+        return 'CONFLICT';
+    if (statusCode === 429)
+        return 'RATE_LIMITED';
+    if (statusCode === 501)
+        return 'NOT_IMPLEMENTED';
+    if (statusCode >= 500)
+        return 'INTERNAL_ERROR';
+    return `HTTP_${statusCode}`;
+}
+function parseJsonObjectString(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function isJsonContentType(contentType) {
+    return typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+}
+export function normalizeApiErrorPayload(input) {
+    const { payload, statusCode, requestId, contentType } = input;
+    if (statusCode < 400)
+        return payload;
+    if (typeof contentType === 'string' && contentType.includes('text/event-stream'))
+        return payload;
+    let source = null;
+    if (payload && typeof payload === 'object' && !Array.isArray(payload) && !(payload instanceof Buffer)) {
+        source = payload;
+    }
+    else if (typeof payload === 'string' && isJsonContentType(contentType)) {
+        source = parseJsonObjectString(payload);
+    }
+    if (!source)
+        return payload;
+    const legacyError = typeof source.error === 'string' ? source.error : undefined;
+    const sourceMessage = typeof source.message === 'string' ? source.message : undefined;
+    const message = sourceMessage ?? legacyError ?? defaultErrorMessage(statusCode);
+    const code = typeof source.code === 'string' ? source.code : mapStatusToCode(statusCode);
+    const envelope = {
+        code,
+        message,
+        requestId,
+        error: legacyError ?? message,
+    };
+    if (source.details !== undefined) {
+        envelope.details = source.details;
+    }
+    if (typeof payload === 'string') {
+        return JSON.stringify(envelope);
+    }
+    return envelope;
+}

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/dist/server.js

@@ -41,6 +41,7 @@ import { execFileSync } from 'node:child_process';
 import { negotiate } from './handshake.js';
 import { diagnosticsBus } from './diagnostics.js';
 import { setStructuredLogSink } from './logger.js';
+import { normalizeApiErrorPayload } from './api-error-envelope.js';
 import { authKeySchema, sendMessageSchema, commandSchema, bashSchema, screenshotSchema, permissionHookSchema, stopHookSchema, batchSessionSchema, pipelineSchema, handshakeRequestSchema, parseIntSafe, isValidUUID, compareSemver, extractCCVersion, MIN_CC_VERSION, } from './validation.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -129,7 +130,8 @@ app.addHook('onSend', (req, reply, payload, done) => {
     reply.header('X-Frame-Options', 'DENY');
     reply.header('Referrer-Policy', 'strict-origin-when-cross-origin');
     reply.header('Permissions-Policy', 'camera=(), microphone=()');
-    done();
+    const normalizedPayload = normalizeApiErrorPayload({ payload, statusCode: reply.statusCode, requestId: req.id, contentType: typeof contentType === "string" ? contentType : undefined });
+    done(null, normalizedPayload);
 });
 const ipRateLimits = new Map();
 const IP_WINDOW_MS = 60_000;

package/package.json

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