@jack200714/mafw 4.5.1

package/gateway/dist/resources/sdk-session.js

@@ -0,0 +1,202 @@
+"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.SdkSessionResource = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const memory_injector_1 = require("../interceptors/memory-injector");
+class SdkSessionResource {
+    opencodeClient;
+    sessions = new Map();
+    sessionsDir;
+    promptAsync;
+    prompt;
+    constructor(opencodeClient, mafwDir) {
+        this.opencodeClient = opencodeClient;
+        this.sessionsDir = mafwDir ? path.join(mafwDir, 'sessions') : '';
+        this.promptAsync = this._rawPromptAsync.bind(this);
+        this.prompt = this._rawPrompt.bind(this);
+        this.loadFromDisk();
+    }
+    loadFromDisk() {
+        if (!this.sessionsDir || !fs.existsSync(this.sessionsDir))
+            return;
+        for (const file of fs.readdirSync(this.sessionsDir).filter((f) => f.endsWith('.json'))) {
+            try {
+                const record = JSON.parse(fs.readFileSync(path.join(this.sessionsDir, file), 'utf-8'));
+                if (record.id)
+                    this.sessions.set(record.id, record);
+            }
+            catch { /* skip corrupt */ }
+        }
+    }
+    saveToDisk(record) {
+        if (!this.sessionsDir)
+            return;
+        if (!fs.existsSync(this.sessionsDir))
+            fs.mkdirSync(this.sessionsDir, { recursive: true });
+        fs.writeFileSync(path.join(this.sessionsDir, `${record.id}.json`), JSON.stringify(record, null, 2), 'utf-8');
+    }
+    setClient(client) { this.opencodeClient = client; }
+    isReady() { return !!this.opencodeClient; }
+    createPromptAsyncWithInjection(memorySearch) {
+        return (0, memory_injector_1.withMemoryInjection)(this._rawPromptAsync.bind(this), {
+            search: memorySearch,
+            enabled: true,
+            maxFacts: 5,
+            maxTokens: 500,
+        });
+    }
+    async create(directory, metadata) {
+        let id;
+        let projectID;
+        let title;
+        if (this.opencodeClient) {
+            try {
+                const created = await this.opencodeClient.session.create({
+                    directory: directory || '.',
+                });
+                id = created.id;
+                projectID = created.projectID || '';
+                title = created.title || '';
+            }
+            catch {
+                // SDK unavailable — create local-only session
+                id = crypto.randomUUID();
+                projectID = directory || '';
+                title = '';
+            }
+        }
+        else {
+            id = crypto.randomUUID();
+            projectID = directory || '';
+            title = '';
+        }
+        const record = {
+            id,
+            projectID,
+            directory: directory || '.',
+            title,
+            metadata,
+            time: { created: Date.now(), updated: Date.now() },
+        };
+        this.sessions.set(record.id, record);
+        this.saveToDisk(record);
+        return record;
+    }
+    async registerExternal(id, directory, metadata) {
+        const record = {
+            id,
+            projectID: directory,
+            directory,
+            title: '',
+            metadata,
+            time: { created: Date.now(), updated: Date.now() },
+        };
+        this.sessions.set(record.id, record);
+        this.saveToDisk(record);
+        return record;
+    }
+    /** Replace (not merge) a session's metadata and persist. Returns null if unknown. */
+    async updateMetadata(id, metadata) {
+        const record = this.sessions.get(id);
+        if (!record)
+            return null;
+        record.metadata = metadata;
+        record.time.updated = Date.now();
+        this.saveToDisk(record);
+        return record;
+    }
+    async _rawPromptAsync(sessionID, message, parts, agent, model) {
+        if (!this.opencodeClient)
+            throw new Error('OpenCode client not available');
+        if (!sessionID)
+            return;
+        const promptParts = [];
+        if (message)
+            promptParts.push({ type: 'text', text: message });
+        if (Array.isArray(parts) && parts.length > 0)
+            promptParts.push(...parts);
+        const promptOpts = { sessionID, parts: promptParts };
+        if (agent)
+            promptOpts.agent = agent;
+        if (model?.providerID && model?.modelID)
+            promptOpts.model = model;
+        await this.opencodeClient.session.promptAsync(promptOpts);
+    }
+    async _rawPrompt(sessionID, parts, system) {
+        if (!this.opencodeClient)
+            throw new Error('OpenCode client not available');
+        if (!sessionID) {
+            return { parts: [] };
+        }
+        const result = await this.opencodeClient.session.prompt({
+            sessionID,
+            parts,
+            system,
+        });
+        const responseText = result.parts
+            ?.filter((p) => p.type === 'text')
+            .map((p) => p.text)
+            .join('\n') || '';
+        return {
+            parts: [{ id: '', sessionID, messageID: '', type: 'text', text: responseText }],
+        };
+    }
+    async delete(sessionID) {
+        if (this.opencodeClient && sessionID) {
+            await this.opencodeClient.session.delete({ sessionID }).catch(() => { });
+        }
+        this.sessions.delete(sessionID);
+        if (this.sessionsDir) {
+            const filePath = path.join(this.sessionsDir, `${sessionID}.json`);
+            if (fs.existsSync(filePath))
+                fs.unlinkSync(filePath);
+        }
+    }
+    async list() {
+        return Array.from(this.sessions.values());
+    }
+    async listByProject(projectID) {
+        return Array.from(this.sessions.values())
+            .filter(s => s.projectID === projectID || s.directory === projectID)
+            .sort((a, b) => (b.time?.created || 0) - (a.time?.created || 0));
+    }
+    async get(id) {
+        return this.sessions.get(id) || null;
+    }
+}
+exports.SdkSessionResource = SdkSessionResource;

package/gateway/dist/retrieval/guided-retriever.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidedRetriever = void 0;
+/** Per-hop decay: first hop full strength, subsequent hops progressively damped. */
+const HOP_DECAY = [1.0, 0.9, 0.75];
+/** BM25 parameters matching production HarmonicIndexManager. */
+const BM25_K1 = 1.2;
+const BM25_B = 0.75;
+class GuidedRetriever {
+    indexManager;
+    constructor(indexManager) {
+        this.indexManager = indexManager;
+    }
+    search(query, options = {}) {
+        const policy = options.policy || 'guided';
+        const maxRounds = options.maxRounds || 3;
+        const results = [];
+        const index = this.indexManager.getIndex();
+        const entries = index.entries;
+        if (policy === 'oneshot') {
+            return this.bm25Search(query, entries, 0, 1.0).slice(0, 10);
+        }
+        let currentQuery = query;
+        for (let round = 0; round < maxRounds; round++) {
+            const hopDecay = HOP_DECAY[round] ?? HOP_DECAY[HOP_DECAY.length - 1];
+            const roundResults = this.bm25Search(currentQuery, entries, round, hopDecay);
+            results.push(...roundResults);
+            // Saturation detection: stop expanding if results are already excellent
+            // or if additional rounds aren't surfacing new relevant entries.
+            if (roundResults.length > 0 && roundResults[0].score >= 0.8)
+                break;
+            if (roundResults.length >= 3) {
+                const scores = roundResults.slice(0, 3).map(r => r.score);
+                const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
+                const variance = scores.reduce((a, b) => a + (b - avg) ** 2, 0) / scores.length;
+                // Only stop early if scores are uniformly high AND low variance
+                if (variance < 0.01 && avg > 0.5)
+                    break;
+            }
+            // Query expansion: append top result's cue_anchors to query for next hop
+            if (roundResults.length > 0) {
+                const topEntry = entries.find((e) => e.id === roundResults[0].id);
+                if (topEntry && topEntry.cue_anchors?.length) {
+                    currentQuery = query + ' ' + topEntry.cue_anchors.slice(0, 3).join(' ');
+                }
+            }
+        }
+        // Deduplicate by id, keep highest score
+        const seen = new Map();
+        for (const r of results) {
+            if (!seen.has(r.id) || r.score > seen.get(r.id).score) {
+                seen.set(r.id, r);
+            }
+        }
+        return [...seen.values()].sort((a, b) => b.score - a.score).slice(0, 10);
+    }
+    /**
+     * Production-quality BM25 scoring: k1=1.2, b=0.75, with energy × salience
+     * weighting and superseded/merged_from penalties — matches
+     * HarmonicIndexManager.bm25SearchScored() semantics.
+     */
+    bm25Search(query, entries, round, hopDecay) {
+        const N = entries.length;
+        if (N === 0)
+            return [];
+        const queryTokens = this.tokenizeBM25(query);
+        if (queryTokens.length === 0)
+            return [];
+        const docs = entries.map(entry => {
+            const text = (entry.primary_abstraction + ' ' + (entry.cue_anchors?.join(' ') || '')).toLowerCase();
+            return { entry, toks: this.tokenizeBM25(text) };
+        });
+        const docLengths = docs.map(d => d.toks.length);
+        const avgdl = docLengths.reduce((a, c) => a + c, 0) / N;
+        // Document frequency for query tokens
+        const df = new Map();
+        for (const d of docs) {
+            for (const t of new Set(d.toks)) {
+                df.set(t, (df.get(t) || 0) + 1);
+            }
+        }
+        const idf = new Map();
+        for (const t of queryTokens) {
+            const dfT = df.get(t) || 0;
+            idf.set(t, Math.log((N - dfT + 0.5) / (dfT + 0.5) + 1));
+        }
+        const scored = [];
+        docs.forEach((d, i) => {
+            const dl = docLengths[i];
+            let score = 0;
+            for (const t of queryTokens) {
+                let tf = 0;
+                for (const tok of d.toks)
+                    if (tok === t)
+                        tf++;
+                if (tf === 0)
+                    continue;
+                score += (idf.get(t) || 0) * (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * (dl / avgdl)));
+            }
+            if (score > 0) {
+                // Apply energy × salience weighting and superseded/merged penalties
+                const energy = d.entry.energy || 0.5;
+                const salience = d.entry.salience ?? 1;
+                const supersededPenalty = d.entry.superseded_by ? 0.5 : 1;
+                const mergedPenalty = (d.entry.merged_from?.length ?? 0) > 0 ? 0.8 : 1;
+                score = score * energy * salience * supersededPenalty * mergedPenalty * hopDecay;
+                scored.push({
+                    id: d.entry.id,
+                    primary_abstraction: d.entry.primary_abstraction,
+                    score,
+                    round,
+                    hopDecay,
+                });
+            }
+        });
+        return scored.sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Tokenize text for BM25: lowercase words (len>=2) + CJK unigrams.
+     * Matches HarmonicIndexManager.tokenizeBM25() semantics.
+     */
+    tokenizeBM25(text) {
+        const tokens = [];
+        const words = text.toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length >= 2);
+        tokens.push(...words);
+        const cjk = text.toLowerCase().match(/[\u4e00-\u9fff]/g) || [];
+        tokens.push(...cjk);
+        return tokens;
+    }
+}
+exports.GuidedRetriever = GuidedRetriever;

package/gateway/dist/retrieval/idf-stats.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDFStats = void 0;
+class IDFStats {
+    df = new Map();
+    n = 0;
+    threshold;
+    constructor(threshold = 0.5) {
+        this.threshold = threshold;
+    }
+    addDocument(terms) {
+        this.n++;
+        const unique = new Set(terms);
+        for (const term of unique) {
+            this.df.set(term, (this.df.get(term) || 0) + 1);
+        }
+    }
+    idf(term) {
+        const freq = this.df.get(term) || 0;
+        if (freq === 0)
+            return 0;
+        return Math.log(this.n / freq);
+    }
+    getThresholdIdf() {
+        return this.threshold;
+    }
+    isNoisy(term) {
+        return this.idf(term) < this.threshold;
+    }
+}
+exports.IDFStats = IDFStats;

package/gateway/dist/routes/embedding-config.js

@@ -0,0 +1,100 @@
+"use strict";
+// GET/POST /api/memory/embedding-config — memory-system embedding settings.
+//
+// Follows the model-config.ts deps-injection pattern. POST validates, persists
+// to config.yaml, then HOT-SWAPs the embedding runtime (kill old sidecar →
+// re-init provider + vector store → background backfill) so an engine switch
+// does not require a gateway restart.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEmbeddingConfigGet = handleEmbeddingConfigGet;
+exports.handleEmbeddingConfigUpdate = handleEmbeddingConfigUpdate;
+const PROVIDERS = ['off', 'local', 'dashscope'];
+const ENGINES = ['onnx', 'llamacpp'];
+const GPUS = ['cpu', 'vulkan', 'cuda'];
+function send(res, status, body) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', (c) => { data += c.toString(); if (data.length > 1e6)
+            reject(new Error('body too large')); });
+        req.on('end', () => resolve(data));
+        req.on('error', reject);
+    });
+}
+async function handleEmbeddingConfigGet(_req, res, deps) {
+    send(res, 200, {
+        current: deps.currentConfig(),
+        runtime: deps.runtimeState(),
+        available: { providers: PROVIDERS, engines: ENGINES, gpus: GPUS },
+    });
+}
+async function handleEmbeddingConfigUpdate(req, res, deps) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        send(res, 400, { error: 'invalid JSON body' });
+        return;
+    }
+    if (!body || Object.keys(body).length === 0) {
+        send(res, 400, { error: 'empty body' });
+        return;
+    }
+    // ── validate ──
+    const errors = [];
+    if (body.provider !== undefined && !PROVIDERS.includes(body.provider)) {
+        errors.push(`provider must be one of ${PROVIDERS.join('|')}`);
+    }
+    if (body.engine !== undefined && !ENGINES.includes(body.engine)) {
+        errors.push(`engine must be one of ${ENGINES.join('|')}`);
+    }
+    if (body.threads !== undefined && (!Number.isInteger(body.threads) || body.threads < 1 || body.threads > 32)) {
+        errors.push('threads must be an integer in 1..32');
+    }
+    if (body.llamacpp?.gpu !== undefined && !GPUS.includes(body.llamacpp.gpu)) {
+        errors.push(`llamacpp.gpu must be one of ${GPUS.join('|')}`);
+    }
+    if (body.llamacpp?.threads !== undefined && (!Number.isInteger(body.llamacpp.threads) || body.llamacpp.threads < 1 || body.llamacpp.threads > 32)) {
+        errors.push('llamacpp.threads must be an integer in 1..32');
+    }
+    if (body.llamacpp?.contextSize !== undefined && (!Number.isInteger(body.llamacpp.contextSize) || body.llamacpp.contextSize < 256 || body.llamacpp.contextSize > 32768)) {
+        errors.push('llamacpp.contextSize must be an integer in 256..32768');
+    }
+    if (errors.length > 0) {
+        send(res, 400, { error: errors.join('; ') });
+        return;
+    }
+    // ── persist ──
+    const embedding = {};
+    if (body.provider !== undefined)
+        embedding.provider = body.provider;
+    if (body.engine !== undefined)
+        embedding.engine = body.engine;
+    if (body.model !== undefined)
+        embedding.model = body.model;
+    if (body.threads !== undefined)
+        embedding.threads = body.threads;
+    if (body.llamacpp && Object.keys(body.llamacpp).length > 0)
+        embedding.llamacpp = body.llamacpp;
+    deps.persist({ memory: { embedding } });
+    // ── hot-swap the runtime ──
+    const reinit = deps.reinit();
+    const newCfg = deps.currentConfig();
+    // Engine/provider/model changes invalidate existing vectors (different
+    // embedding space) — kick off a background backfill; the indexer skips
+    // entries whose vectors already exist in the new provider's store file.
+    if (reinit.active)
+        deps.scheduleBackfill();
+    send(res, 200, {
+        success: true,
+        current: newCfg,
+        runtime: deps.runtimeState(),
+        note: reinit.active
+            ? 'embedding runtime rebuilt; background backfill started'
+            : 'embedding provider off — dense channel disabled',
+    });
+}

package/gateway/dist/routes/goal-sessions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGoalSessions = handleGoalSessions;
+function json(res, status, payload) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+/**
+ * GET /api/goals/:id/sessions — goal 的 session 映射（编排可视化下钻）。
+ * 数据源 goal_sessions 表（phase-orchestrator onSessionCreated 追加），
+ * 按 runtime session.get 富化 title/time（fail-open）。
+ * 返回 handled=false 表示路径不匹配，交给后续路由。
+ */
+async function handleGoalSessions(req, res, url, deps) {
+    const m = url.match(/^\/api\/goals\/([^/]+)\/sessions(?:\?|$)/);
+    if (!m || req.method !== 'GET')
+        return false;
+    const goalId = decodeURIComponent(m[1]);
+    try {
+        const rows = await deps.listGoalSessions(goalId);
+        const sessions = await Promise.all((rows ?? []).map(async (r) => {
+            const out = {
+                sessionID: r.session_id,
+                phase: r.phase,
+                loop: r.loop,
+            };
+            try {
+                const info = deps.getSession ? await deps.getSession(r.session_id) : null;
+                if (info) {
+                    if (typeof info.title === 'string')
+                        out.title = info.title;
+                    if (info.time)
+                        out.time = info.time;
+                }
+            }
+            catch { /* 富化 fail-open */ }
+            return out;
+        }));
+        json(res, 200, { sessions });
+    }
+    catch (err) {
+        json(res, 500, { error: err?.message ?? String(err) });
+    }
+    return true;
+}

package/gateway/dist/routes/manager-rotate.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runManagerRotate = runManagerRotate;
+exports.handleManagerRotate = handleManagerRotate;
+const logger_1 = require("../core/utils/logger");
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+async function runManagerRotate(projectDir, deps) {
+    return deps.lock(projectDir, async () => {
+        const existing = deps.getManagerSession(projectDir);
+        if (!existing?.sessionId) {
+            const sessionId = await deps.ensure(projectDir);
+            return { sessionId, created: 'initial' };
+        }
+        try {
+            await deps.downgrade(existing.sessionId);
+        }
+        catch (err) {
+            // Old-session metadata residue only affects the desktop role fallback
+            // (fixed separately); rotation must not be blocked by it.
+            logger_1.log.warn(`[ManagerRotate] downgrade old session failed (continuing): ${err.message}`);
+        }
+        const sessionId = await deps.create(projectDir);
+        return { sessionId, previousSessionId: existing.sessionId, created: 'rotated' };
+    });
+}
+async function handleManagerRotate(req, res, deps) {
+    let body = {};
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch { /* default {} */ }
+    const projectDir = typeof body?.projectDir === 'string' && body.projectDir.trim() ? body.projectDir : null;
+    if (!projectDir) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'projectDir is required' }));
+        return;
+    }
+    try {
+        const result = await runManagerRotate(projectDir, deps);
+        logger_1.log.info(`[ManagerRotate] rotated manager session for ${projectDir}: ${result.previousSessionId ?? '-'} -> ${result.sessionId} (${result.created})`);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, ...result }));
+    }
+    catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+    }
+}

package/gateway/dist/routes/media-switch.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMediaSwitch = handleMediaSwitch;
+const logger_1 = require("../core/utils/logger");
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => body += chunk);
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+const MODALITIES = ['image', 'video', 'audio'];
+async function handleMediaSwitch(req, res, deps) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch (err) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+        return;
+    }
+    const available = [...deps.availableEngines(), 'pi'];
+    const validateEngine = (engine) => {
+        if (!engine || engine === 'pi')
+            return 'pi';
+        if (available.includes(engine))
+            return engine;
+        return null;
+    };
+    const mediaUpdate = {};
+    if (body.engine !== undefined) {
+        const validated = validateEngine(body.engine);
+        if (validated === null) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Media engine '${body.engine}' not found`, available }));
+            return;
+        }
+        mediaUpdate.engine = validated;
+    }
+    for (const modality of MODALITIES) {
+        if (body[modality]?.engine !== undefined) {
+            const validated = validateEngine(body[modality].engine);
+            if (validated === null) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: `Media engine '${body[modality].engine}' not found for ${modality}`, available }));
+                return;
+            }
+            mediaUpdate[modality] = { engine: validated };
+        }
+    }
+    if (Object.keys(mediaUpdate).length === 0) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'No engine specified' }));
+        return;
+    }
+    try {
+        deps.persist({ media: mediaUpdate });
+        await deps.reloadPlugins();
+        logger_1.log.info(`[Media] switched engine: ${JSON.stringify(mediaUpdate)}`);
+        const cur = deps.currentMedia();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            media: {
+                engine: cur.engine,
+                image: cur.image,
+                video: cur.video,
+                audio: cur.audio,
+            },
+        }));
+    }
+    catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+    }
+}