@jack200714/mafw 4.5.1

package/gateway/dist/mcp/handlers/run-automation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRunAutomation = void 0;
+const handleRunAutomation = async (args, { automation, ledger }) => {
+    try {
+        const ruleId = args.rule_id;
+        if (!automation)
+            throw new Error('Automation engine not available');
+        if (!ledger)
+            throw new Error('Ledger not available');
+        const result = await automation.runRuleFromLLM(ruleId, ledger);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: 'executed',
+                        triage_id: result.triageId,
+                        message: result.message,
+                        note: 'auto_confirm was forced to false — result is PENDING_CONFIRMATION',
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleRunAutomation = handleRunAutomation;

package/gateway/dist/mcp/handlers/search-hybrid.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSearchHybrid = void 0;
+exports.encodeState = encodeState;
+exports.decodeState = decodeState;
+const config_1 = require("../../config");
+const harmonic_file_store_1 = require("../../memory/harmonic-file-store");
+const reranker_1 = require("../../core/memory/reranker");
+const embedding_runtime_1 = require("../../memory/embedding-runtime");
+function encodeState(s) {
+    return Buffer.from(JSON.stringify(s), 'utf8').toString('base64url');
+}
+function decodeState(raw) {
+    if (!raw)
+        return null;
+    try {
+        const s = JSON.parse(Buffer.from(raw, 'base64url').toString('utf8'));
+        if (!Array.isArray(s?.seen) || !Array.isArray(s?.frontier) || typeof s?.round !== 'number')
+            return null;
+        return {
+            seen: s.seen.filter((x) => typeof x === 'string'),
+            frontier: s.frontier
+                .filter((x) => typeof x?.id === 'string')
+                .map((x) => ({ id: x.id, weight: Number(x.weight) || 1 })),
+            round: s.round,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// 兼容生产（MemoryService.harmonicIndex.*）与测试（裸 HarmonicIndexManager）两种访问路径
+function getGraphStore(memory) {
+    return memory?.harmonicIndex?.getAnchorGraphStore?.() ?? memory?.getAnchorGraphStore?.() ?? null;
+}
+function getIndexEntries(memory) {
+    return memory?.harmonicIndex?.getIndex?.()?.entries ?? memory?.getIndex?.()?.entries ?? [];
+}
+const handleSearchHybrid = async (args, { memory, mafwDir }) => {
+    try {
+        const query = args.query;
+        const topK = args.topK || config_1.config.search.defaultTopK;
+        const retrieverArg = args.retriever || config_1.config.search.defaultRetriever;
+        // 'hybrid' = BM25 + dense (embedding) fused via RRF inside searchScored.
+        const searchOpts = {
+            retriever: retrieverArg === 'hybrid' ? 'bm25' : retrieverArg,
+        };
+        if (retrieverArg === 'hybrid') {
+            const dense = await (0, embedding_runtime_1.computeDenseScores)(query, topK * 4, memory?.harmonicIndex);
+            if (dense)
+                searchOpts.denseScores = dense;
+        }
+        const maxRounds = config_1.config.search.maxExpandRounds;
+        const graphStore = getGraphStore(memory);
+        const prev = decodeState(args.state);
+        let scored;
+        let seen;
+        let frontier;
+        let round;
+        if (!prev) {
+            // ── 首轮：现有行为原样（searchScored 已含图扩展+融合）+ 计算 frontier ──
+            scored = memory.search(query, topK * 2, searchOpts).map((e) => ({ entry: e, score: 1, graphScore: 0 }));
+            seen = scored.map(s => s.entry.id);
+            frontier = computeFrontier(graphStore, scored.map(s => s.entry.id), new Set(seen));
+            round = 0;
+        }
+        else if (prev.round >= maxRounds) {
+            // ── 轮次已满：不扩展、不消费 frontier，仅返回 bm25 新命中增量 ──
+            const seenSet = new Set(prev.seen);
+            scored = memory.search(query, topK * 2, searchOpts)
+                .filter((e) => !seenSet.has(e.id))
+                .map((e) => ({ entry: e, score: 1, graphScore: 0 }));
+            seen = prev.seen;
+            frontier = prev.frontier;
+            round = prev.round;
+        }
+        else {
+            // ── 迭代轮：frontier 条目(graph-only 评分) + bm25 新命中，统一归一化融合 ──
+            round = prev.round + 1;
+            const seenSet = new Set(prev.seen);
+            const entries = getIndexEntries(memory);
+            const frontierHits = [];
+            for (const f of prev.frontier) {
+                if (seenSet.has(f.id))
+                    continue;
+                const entry = entries.find((e) => e.id === f.id);
+                if (!entry || entry.superseded_by)
+                    continue;
+                frontierHits.push({ entry, score: 0, graphScore: f.weight * (entry.energy ?? 0.8) * (entry.salience ?? 1) });
+            }
+            const freshHits = memory.search(query, topK * 2, searchOpts)
+                .filter((e) => !seenSet.has(e.id))
+                .map((e) => ({ entry: e, score: 1, graphScore: 0 }));
+            const union = mergeById(frontierHits, freshHits);
+            const norm = (vals) => {
+                if (vals.length === 0)
+                    return [];
+                const min = Math.min(...vals), max = Math.max(...vals);
+                if (max === min)
+                    return vals.map(() => 0.5);
+                return vals.map(v => (v - min) / (max - min));
+            };
+            const nb = norm(union.map(u => u.score));
+            const ng = norm(union.map(u => u.graphScore));
+            const gw = config_1.config.search.graph.rerankGraphWeight;
+            scored = union.map((u, i) => ({ ...u, score: (1 - gw) * nb[i] + gw * ng[i] }))
+                .sort((a, b) => b.score - a.score);
+            seen = [...prev.seen];
+            for (const s of scored)
+                if (!seen.includes(s.entry.id))
+                    seen.push(s.entry.id);
+            // 新 frontier = 本次新结果邻居 + 剩余旧 frontier（未消费项，去重）
+            const consumed = new Set(scored.map(s => s.entry.id));
+            const remaining = prev.frontier.filter(f => !consumed.has(f.id) && !seen.includes(f.id));
+            frontier = [...computeFrontier(graphStore, scored.map(s => s.entry.id), new Set(seen)), ...remaining];
+        }
+        // cross-encoder reranking（handler-level，不改 searchScored 同步签名）
+        if (config_1.config.search.reranker === 'cross-encoder' && scored.length > 0) {
+            const reranker = (0, reranker_1.createReranker)('cross-encoder');
+            if (reranker) {
+                scored = (await (0, reranker_1.applyReranker)(query, scored, reranker, topK * 2))
+                    .map(s => ({ entry: s.entry, score: s.score, graphScore: 0 }));
+            }
+        }
+        // memoryType 后置过滤（首轮与迭代轮一致）
+        const results = scored.filter((r) => !args.memoryType || r.entry.type === args.memoryType)
+            .slice(0, topK)
+            .map(r => r.entry);
+        const canExpand = frontier.length > 0 && round < maxRounds;
+        // Enrich with full memory_value from OKF store.
+        const store = new harmonic_file_store_1.HarmonicUnitFileStore(mafwDir || config_1.config.resolvePath());
+        const enriched = [];
+        for (const r of results) {
+            let unit = null;
+            try {
+                unit = await store.read(r.id);
+            }
+            catch { /* keep entry-only */ }
+            enriched.push({ ...r, memory_value: unit?.memory_value || r.memory_value || '' });
+        }
+        const state = canExpand || round > 0 ? encodeState({ seen, frontier, round }) : null;
+        const hint = canExpand
+            ? '如需更多相关记忆，携带 state 再次调用本工具继续扩展检索。'
+            : frontier.length === 0
+                ? '已无更多可扩展的相关记忆。'
+                : '已达最大扩展轮数。';
+        return { content: [{ type: "text", text: JSON.stringify({ results: enriched, canExpand, state, round, count: enriched.length, hint }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleSearchHybrid = handleSearchHybrid;
+function computeFrontier(graphStore, ids, exclude) {
+    if (!graphStore || ids.length === 0)
+        return [];
+    const result = [];
+    for (const id of ids) {
+        const neighbors = graphStore.getNeighbors([id], config_1.config.search.graph.maxNeighbors, exclude);
+        for (const [nbId, info] of neighbors) {
+            if (!result.some(f => f.id === nbId))
+                result.push({ id: nbId, weight: info.weight });
+        }
+        if (result.length >= 30)
+            break;
+    }
+    return result;
+}
+function mergeById(a, b) {
+    const byId = new Map();
+    for (const item of [...a, ...b]) {
+        const existing = byId.get(item.entry.id);
+        if (!existing)
+            byId.set(item.entry.id, item);
+        else {
+            existing.score = Math.max(existing.score, item.score);
+            existing.graphScore = Math.max(existing.graphScore, item.graphScore);
+        }
+    }
+    return [...byId.values()];
+}

package/gateway/dist/mcp/handlers/supersede-memory.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSupersedeMemory = void 0;
+const config_1 = require("../../config");
+/**
+ * Mark one or more existing memories as superseded. Use this when a new fact
+ * contradicts or replaces an old memory but you don't need to write a new
+ * entry (e.g., the user explicitly retracts a preference). For the common
+ * case of "new memory replaces old", use mafw_add_memory with the supersedes
+ * field instead.
+ */
+const handleSupersedeMemory = async (args, { memory, mafwDir }) => {
+    try {
+        const ids = args.ids;
+        const reason = args.reason || 'superseded by agent';
+        if (!Array.isArray(ids) || ids.length === 0) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: 'ids must be a non-empty array' }) }], isError: true };
+        }
+        const resolvedDir = mafwDir ?? config_1.config.resolvePath();
+        const { HarmonicUnitFileStore } = await import("../../memory/harmonic-file-store.js");
+        const sharedIndex = memory?.harmonicIndex;
+        const sharedGraph = memory?.harmonicIndex?.getAnchorGraphStore?.()
+            ?? memory?.getAnchorGraphStore?.() ?? undefined;
+        const store = sharedIndex
+            ? new HarmonicUnitFileStore(resolvedDir, sharedIndex, sharedGraph)
+            : new HarmonicUnitFileStore(resolvedDir, undefined, sharedGraph);
+        // Use a synthetic "by" id to mark the supersession source. This is a
+        // tombstone marker — the old entries are kept but demoted in search.
+        const byId = `__agent_supersede__${Date.now()}`;
+        const supersededIds = [];
+        for (const id of ids) {
+            if (store.markSuperseded(id, byId)) {
+                supersededIds.push(id);
+            }
+        }
+        return { content: [{ type: "text", text: JSON.stringify({
+                        success: true,
+                        superseded: supersededIds,
+                        skipped: ids.filter(id => !supersededIds.includes(id)),
+                        reason,
+                    }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleSupersedeMemory = handleSupersedeMemory;

package/gateway/dist/mcp/handlers/update-state.js

@@ -0,0 +1,59 @@
+"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.handleUpdateState = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const event_bus_1 = require("../../event-bus");
+const projectDir = process.env.MAFW_PROJECT_DIR || process.cwd();
+const handleUpdateState = async (args) => {
+    try {
+        const goalId = args.goalId;
+        const patch = args.patch;
+        const mafwDir = path.join(projectDir, ".mafw");
+        const statePath = path.join(mafwDir, "state", `${goalId}.json`);
+        const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+        const updated = { ...state, ...patch, updatedAt: new Date().toISOString() };
+        const tmpPath = `${statePath}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(updated, null, 2), "utf-8");
+        fs.renameSync(tmpPath, statePath);
+        event_bus_1.eventBus.emit("state_change", { type: "state_change", goalId, patch, projectDir });
+        return { content: [{ type: "text", text: JSON.stringify(updated) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleUpdateState = handleUpdateState;

package/gateway/dist/mcp/handlers/validate-rule.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleValidateRule = void 0;
+const handleValidateRule = async (args, { automation }) => {
+    try {
+        if (!automation)
+            throw new Error('Automation engine not available');
+        const trigger = args.trigger || {};
+        const rule = {
+            id: args.id,
+            enabled: false,
+            trigger: {
+                type: 'cron',
+                schedule: trigger.schedule || '',
+                timezone: trigger.timezone || 'UTC',
+            },
+            skill: args.skill,
+            action: args.action,
+            onResult: args.onResult,
+            goal_defaults: args.goal_defaults,
+        };
+        const result = automation.validateRule(rule);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        valid: result.valid,
+                        errors: result.errors,
+                        nextTriggers: result.nextTriggers,
+                        note: result.valid ? 'Rule is valid — nothing was saved' : 'Rule has errors — see errors array',
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleValidateRule = handleValidateRule;

package/gateway/dist/mcp/sse-transport.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpSSEEndpoint = void 0;
+const config_1 = require("../config");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const logger_1 = require("../core/utils/logger");
+/**
+ * Legacy SSE MCP endpoint (kept for pre-StreamableHTTP clients; opencode
+ * prefers the stateless StreamableHTTP handler on the same path).
+ *
+ * Session-isolation contract (regression-tested in
+ * tests/unit/mcp-sse-multi-client.test.ts): EVERY SSE connection gets its own
+ * `Server` instance. The MCP SDK `Protocol` supports exactly one transport —
+ * sharing a single Server across sessions routed responses to whichever
+ * client connected last, starving everyone else (the 2026-09-09 "-32001
+ * intermittent timeout" incident).
+ *
+ * Each stream also carries `: ping` keep-alive comment frames so idle
+ * connections are not killed by client-side idle timeouts (observed ~305s
+ * aborts) and half-open connections are detected on write failure.
+ */
+class McpSSEEndpoint {
+    toolRegistry;
+    services;
+    heartbeatMs;
+    sessions = new Map();
+    constructor(toolRegistry, services, opts) {
+        this.toolRegistry = toolRegistry;
+        this.services = services;
+        this.heartbeatMs = opts?.heartbeatMs ?? 15000;
+    }
+    createServer() {
+        const server = new index_js_1.Server({ name: config_1.config.mcpserver.name, version: config_1.config.mcpserver.version }, { capabilities: { tools: {} } });
+        server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: this.toolRegistry.definitions,
+        }));
+        server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+            const handler = this.toolRegistry.handlers[req.params.name];
+            if (!handler) {
+                throw new Error(`Unknown tool: ${req.params.name}`);
+            }
+            const args = req.params.arguments ?? {};
+            return handler(args, this.services);
+        });
+        return server;
+    }
+    sessionCount() {
+        return this.sessions.size;
+    }
+    async handleSSE(req, res) {
+        const transport = new sse_js_1.SSEServerTransport("/mcp", res);
+        const sessionId = transport.sessionId;
+        const server = this.createServer();
+        const heartbeat = this.heartbeatMs > 0
+            ? setInterval(() => {
+                // Comment frames are ignored by every SSE parser; a write failure
+                // surfaces as res 'error'/'close' and cleans the session up.
+                try {
+                    res.write(": ping\n\n");
+                }
+                catch {
+                    // cleaned up via 'close'
+                }
+            }, this.heartbeatMs)
+            : null;
+        if (heartbeat)
+            heartbeat.unref();
+        const cleanup = () => {
+            if (heartbeat)
+                clearInterval(heartbeat);
+            if (this.sessions.delete(sessionId)) {
+                logger_1.log.info(`[MCP] SSE session closed ${sessionId.slice(0, 8)} (active: ${this.sessions.size})`);
+            }
+            void server.close().catch(() => { });
+        };
+        res.on("close", cleanup);
+        res.on("error", cleanup);
+        this.sessions.set(sessionId, { server, transport, heartbeat: heartbeat });
+        logger_1.log.info(`[MCP] SSE session connected ${sessionId.slice(0, 8)} (active: ${this.sessions.size})`);
+        await server.connect(transport);
+    }
+    async handleMessage(req, res) {
+        const url = new URL(req.url || "", "http://localhost");
+        const sessionId = url.searchParams.get("sessionId") || "";
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            logger_1.log.warn(`[MCP] POST for unknown session ${sessionId.slice(0, 8) || "(empty)"} (active: ${this.sessions.size})`);
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: "Session not found" }));
+            return;
+        }
+        await session.transport.handlePostMessage(req, res);
+    }
+}
+exports.McpSSEEndpoint = McpSSEEndpoint;

package/gateway/dist/mcp/streamable-endpoint.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpStreamableEndpoint = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const config_1 = require("../config");
+const logger_1 = require("../core/utils/logger");
+/**
+ * Stateless StreamableHTTP MCP endpoint (MCP 2025-03-26 transport).
+ *
+ * Served on the same `/mcp` path as the legacy SSE endpoint — clients are
+ * routed by shape (see index.ts): POST without a `sessionId` query param and
+ * GET carrying `mcp-protocol-version` come here; everything else goes to the
+ * legacy SSE handler. opencode's client prefers StreamableHTTP and falls
+ * back to SSE, so modern clients automatically land on this path.
+ *
+ * Stateless contract: every request gets a fresh Server+transport pair and
+ * the JSON-RPC response is returned inline on the POST (no long-lived GET
+ * stream, no session state). This structurally eliminates the response
+ * misrouting bug class and session staleness of the legacy SSE transport.
+ */
+class McpStreamableEndpoint {
+    toolRegistry;
+    services;
+    constructor(toolRegistry, services) {
+        this.toolRegistry = toolRegistry;
+        this.services = services;
+    }
+    createServer() {
+        const server = new index_js_1.Server({ name: config_1.config.mcpserver.name, version: config_1.config.mcpserver.version }, { capabilities: { tools: {} } });
+        server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: this.toolRegistry.definitions,
+        }));
+        server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+            const handler = this.toolRegistry.handlers[req.params.name];
+            if (!handler) {
+                throw new Error(`Unknown tool: ${req.params.name}`);
+            }
+            const args = req.params.arguments ?? {};
+            return handler(args, this.services);
+        });
+        return server;
+    }
+    async handleRequest(req, res) {
+        const server = this.createServer();
+        // Stateless mode: no session id is issued or validated; JSON responses
+        // are returned directly on the POST instead of an SSE stream.
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+            enableJsonResponse: true,
+        });
+        const cleanup = () => {
+            void server.close().catch(() => { });
+            void transport.close().catch(() => { });
+        };
+        res.on("close", cleanup);
+        res.on("error", cleanup);
+        await server.connect(transport);
+        // Collect the JSON-RPC body and hand it to the transport pre-parsed
+        // (we are on raw node:http, not express with a json body parser).
+        const body = await readJsonBody(req);
+        if (body?.method === "initialize") {
+            logger_1.log.info("[MCP] StreamableHTTP initialize (stateless JSON mode)");
+        }
+        await transport.handleRequest(req, res, body);
+    }
+}
+exports.McpStreamableEndpoint = McpStreamableEndpoint;
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 10 * 1024 * 1024) {
+                reject(new Error("MCP request body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if (!raw) {
+                resolve(undefined);
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch (err) {
+                reject(new Error(`Invalid JSON body: ${err.message}`));
+            }
+        });
+        req.on("error", reject);
+    });
+}