@jack200714/mafw 4.5.1

package/gateway/dist/interceptors/memory-injector.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMemoryInjection = withMemoryInjection;
+exports.createMemorySearch = createMemorySearch;
+const inject_format_1 = require("../recall/inject-format");
+/**
+ * Wraps a promptAsync-style function with automatic memory injection.
+ * Injects `<deltas>` and `<facts>` blocks before the user message.
+ * The wrapped function has the exact same signature as the original.
+ */
+function withMemoryInjection(fn, opts) {
+    if (!opts.enabled)
+        return fn;
+    const maxFacts = opts.maxFacts ?? 5;
+    const maxTokens = opts.maxTokens ?? 500;
+    const wrapped = async (sessionID, message, ...rest) => {
+        const results = await opts.search(message, maxFacts);
+        if (results.length === 0)
+            return fn(sessionID, message, ...rest);
+        const entries = [];
+        let totalChars = 0;
+        for (const r of results) {
+            const line = r.source === 'parametric'
+                ? `[Δ ${r.type}] ${r.content}`
+                : `[${r.type}] ${r.content}`;
+            if (totalChars + line.length > maxTokens)
+                break;
+            entries.push({ source: r.source, type: r.type, content: r.content });
+            totalChars += line.length;
+        }
+        const chunks = (0, inject_format_1.renderMemoryBlocks)(entries);
+        if (chunks.length === 0)
+            return fn(sessionID, message, ...rest);
+        const augmented = chunks.join('\n\n') + '\n\n' + message;
+        return fn(sessionID, augmented, ...rest);
+    };
+    return wrapped;
+}
+/**
+ * Builds the search function that merges L3 parametric deltas + Harmonic Index results.
+ */
+function createMemorySearch(parametricStore, deltaInjector, harmonicIndex) {
+    return async (query, maxFacts) => {
+        const results = [];
+        if (parametricStore && deltaInjector) {
+            try {
+                const deltas = parametricStore.match({ loopStage: 'executing' });
+                if (deltas.length > 0) {
+                    const injection = deltaInjector.inject(deltas);
+                    const rendered = deltaInjector.render(injection);
+                    for (const line of rendered.split('\n').filter(Boolean)) {
+                        results.push({ source: 'parametric', type: 'delta', content: line, energy: 0.8 });
+                    }
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        if (harmonicIndex) {
+            try {
+                const entries = harmonicIndex.search(query, maxFacts);
+                for (const e of entries) {
+                    results.push({
+                        source: 'harmonic',
+                        type: e.type,
+                        content: e.primary_abstraction,
+                        energy: e.energy,
+                    });
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        results.sort((a, b) => b.energy - a.energy);
+        return results.slice(0, maxFacts);
+    };
+}

package/gateway/dist/ledger.js

@@ -0,0 +1,121 @@
+"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.SchedulerLedger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+class SchedulerLedger {
+    ledgerPath;
+    constructor(projectDir = '.') {
+        this.ledgerPath = path.join(projectDir, config_1.config.paths.mafwDir, 'ledger.md');
+    }
+    append(entry) {
+        const parts = [
+            `[${entry.timestamp}]`,
+            `[${entry.event}]`,
+        ];
+        if (entry.ruleId)
+            parts.push(`[${entry.ruleId}]`);
+        if (entry.goalId)
+            parts.push(`[${entry.goalId}]`);
+        if (entry.source)
+            parts.push(`source=${entry.source}`);
+        if (entry.reason)
+            parts.push(`reason=${entry.reason}`);
+        if (entry.sessionId)
+            parts.push(`session=${entry.sessionId}`);
+        if (entry.details)
+            parts.push(JSON.stringify(entry.details));
+        fs.appendFileSync(this.ledgerPath, parts.join(' ') + '\n', 'utf-8');
+    }
+    read() {
+        if (!fs.existsSync(this.ledgerPath))
+            return [];
+        const content = fs.readFileSync(this.ledgerPath, 'utf-8');
+        return content.split('\n').filter(Boolean).map(line => this.parse(line));
+    }
+    getHistory(ruleId, limit) {
+        let entries = this.read();
+        if (ruleId) {
+            entries = entries.filter(e => e.ruleId === ruleId);
+        }
+        entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        if (limit && entries.length > limit) {
+            entries = entries.slice(-limit);
+        }
+        return entries.reverse();
+    }
+    parse(line) {
+        const entry = { timestamp: new Date().toISOString(), event: 'UNKNOWN' };
+        const tsMatch = line.match(/^\[(.+?)\]/);
+        if (!tsMatch)
+            return entry;
+        entry.timestamp = tsMatch[1];
+        const eventMatch = line.match(/^\[.+?\] \[(.+?)\]/);
+        if (!eventMatch)
+            return entry;
+        entry.event = eventMatch[1];
+        const rest = line.slice(line.indexOf(']', line.indexOf(']') + 1) + 1).trim();
+        const bracketIds = [...rest.matchAll(/\[([^\]]+)\]/g)];
+        if (bracketIds.length >= 1) {
+            entry.ruleId = bracketIds[0][1];
+        }
+        if (bracketIds.length >= 2) {
+            entry.goalId = bracketIds[1][1];
+        }
+        const sourceMatch = rest.match(/source=(\w+)/);
+        if (sourceMatch && ['cron', 'llm', 'user'].includes(sourceMatch[1])) {
+            entry.source = sourceMatch[1];
+        }
+        const reasonMatch = rest.match(/reason=([^\s{}]+)/);
+        if (reasonMatch)
+            entry.reason = reasonMatch[1];
+        const sessionMatch = rest.match(/session=([^\s{}]+)/);
+        if (sessionMatch)
+            entry.sessionId = sessionMatch[1];
+        const detailsMatch = rest.match(/(\{.+})/);
+        if (detailsMatch) {
+            try {
+                entry.details = JSON.parse(detailsMatch[1]);
+            }
+            catch {
+                entry.details = { raw: detailsMatch[1] };
+            }
+        }
+        return entry;
+    }
+}
+exports.SchedulerLedger = SchedulerLedger;

package/gateway/dist/loop-monitor.js

@@ -0,0 +1,74 @@
+"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.LoopMonitor = void 0;
+/**
+ * Loop Monitor — Loop 心跳监控
+ */
+const fs = __importStar(require("fs"));
+const config_1 = require("./config");
+class LoopMonitor {
+    statusPath;
+    constructor(statusPath) {
+        this.statusPath = statusPath;
+    }
+    isStuck(timeoutMs = config_1.config.timeouts.stuckLoopTimeout) {
+        if (!fs.existsSync(this.statusPath))
+            return false;
+        const content = fs.readFileSync(this.statusPath, 'utf-8');
+        const match = content.match(/updated_at:\s*(.+)/);
+        if (!match)
+            return false;
+        const lastUpdate = new Date(match[1].trim()).getTime();
+        return (Date.now() - lastUpdate) > timeoutMs;
+    }
+    getState() {
+        if (!fs.existsSync(this.statusPath))
+            return null;
+        const content = fs.readFileSync(this.statusPath, 'utf-8');
+        const lines = content.split('\n');
+        const parse = (key) => {
+            const line = lines.find(l => l.startsWith(key + ':'));
+            return line ? line.split(':').slice(1).join(':').trim() : '';
+        };
+        return {
+            goalId: parse('goal_id'),
+            state: parse('state'),
+            loop: parseInt(parse('loop'), 10) || 0,
+            updatedAt: parse('updated_at')
+        };
+    }
+}
+exports.LoopMonitor = LoopMonitor;

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

@@ -0,0 +1,113 @@
+"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.handleAddMemory = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../config");
+const harmonic_types_1 = require("../../core/memory/harmonic-types");
+const salience_perceptor_1 = require("../../core/memory/salience-perceptor");
+const handleAddMemory = async (args, { memory, mafwDir }) => {
+    try {
+        const content = args.content;
+        const memoryType = args.memoryType || config_1.config.memory.defaultMemoryType;
+        const cueAnchors = args.cueAnchors || [];
+        const primaryAbstraction = args.primaryAbstraction || content.slice(0, config_1.config.memory.defaultPrimaryAbstractionLength);
+        const supersedes = args.supersedes || [];
+        const sticky = args.sticky === true;
+        const stickyDays = typeof args.stickyDays === 'number' && args.stickyDays > 0 ? args.stickyDays : 7;
+        if (!["episodic", "semantic", "procedural", "global"].includes(memoryType)) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: `Invalid memoryType: ${memoryType}` }) }], isError: true };
+        }
+        const resolvedDir = mafwDir ?? config_1.config.resolvePath();
+        const memoryDir = path.join(resolvedDir, "memory");
+        if (!fs.existsSync(memoryDir)) {
+            fs.mkdirSync(memoryDir, { recursive: true });
+        }
+        const now = new Date().toISOString();
+        const unitId = (0, harmonic_types_1.generateHarmonicId)();
+        const memCfg = config_1.config.memory;
+        const importance = args.importance;
+        const salience = importance !== undefined
+            ? (0, salience_perceptor_1.importanceToSalience)(importance)
+            : (0, salience_perceptor_1.calculateSalience)(content);
+        const unit = {
+            id: unitId,
+            type: memoryType,
+            primary_abstraction: primaryAbstraction.slice(0, memCfg.abstractionMaxLength),
+            cue_anchors: cueAnchors.slice(0, memCfg.maxCueAnchors),
+            memory_value: content,
+            energy: memCfg.defaultEnergy,
+            salience,
+            abstraction_level: memoryType === "global" ? 3 : memoryType === "episodic" ? 1 : 2,
+            created_at: now,
+            updated_at: now,
+            // Sticky note board: guaranteed per-turn visibility until the date
+            // passes; expiry only removes it from the board, never deletes the memory.
+            ...(sticky ? { sticky_until: new Date(Date.now() + stickyDays * 86400e3).toISOString() } : {}),
+        };
+        const { HarmonicUnitFileStore } = await import("../../memory/harmonic-file-store.js");
+        // Share the in-memory index with the rest of the gateway so that memories
+        // written via MCP are immediately visible to recall, step-injection, and
+        // subsequent searches without requiring a restart.
+        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);
+        // Mark superseded memories before writing the new one. This establishes
+        // the supersede link: old entries get energy halved + search penalty,
+        // new entry becomes the authoritative version.
+        const supersededIds = [];
+        for (const oldId of supersedes) {
+            if (store.markSuperseded(oldId, unitId)) {
+                supersededIds.push(oldId);
+            }
+        }
+        await store.write(unit);
+        return { content: [{ type: "text", text: JSON.stringify({
+                        success: true,
+                        id: unitId,
+                        tier: 'memories',
+                        sticky_until: unit.sticky_until,
+                        superseded: supersededIds.length > 0 ? supersededIds : undefined,
+                    }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleAddMemory = handleAddMemory;

package/gateway/dist/mcp/handlers/ask-user.js

@@ -0,0 +1,63 @@
+"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.handleAskUser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../config");
+const event_bus_1 = require("../../event-bus");
+const handleAskUser = async (args) => {
+    try {
+        const question = args.question;
+        const goalId = args.goalId;
+        const loopNum = args.loopNum;
+        const options = args.options;
+        const priority = args.priority || "normal";
+        const questionDir = path.join(config_1.config.resolvePath(), "user-questions");
+        fs.mkdirSync(questionDir, { recursive: true });
+        const questionId = `q_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+        const questionFile = {
+            id: questionId, goalId, loopNum, question, options, priority,
+            status: "pending", createdAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(path.join(questionDir, `${questionId}.json`), JSON.stringify(questionFile, null, 2), "utf-8");
+        event_bus_1.eventBus.emit("user_question", { type: "user_question", goalId, questionId });
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, questionId, status: "pending" }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleAskUser = handleAskUser;

package/gateway/dist/mcp/handlers/commit-heuristic.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCommitHeuristic = void 0;
+const handleCommitHeuristic = async (args, { memory }) => {
+    try {
+        const pattern = args.pattern;
+        const triggerContext = args.triggerContext || [];
+        const sourceGoalIds = args.sourceGoalIds || [];
+        if (!pattern) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "pattern is required" }) }], isError: true };
+        }
+        const heuristic = memory.l5.addHeuristic(pattern, triggerContext, sourceGoalIds);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, id: heuristic.id, energy: heuristic.energy }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleCommitHeuristic = handleCommitHeuristic;

package/gateway/dist/mcp/handlers/create-goal.js

@@ -0,0 +1,83 @@
+"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.handleCreateGoal = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const event_bus_1 = require("../../event-bus");
+const handleCreateGoal = async (args) => {
+    try {
+        // 调用时读取（非模块顶层）：测试需要按用例隔离 MAFW_PROJECT_DIR
+        const projectDir = process.env.MAFW_PROJECT_DIR || process.cwd();
+        const goalId = args.goalId;
+        const title = args.title;
+        const charter = args.charter;
+        const source = args.source || "user";
+        const metrics = args.metrics || {};
+        const boundaries = args.boundaries || [];
+        const priority = args.priority || "medium";
+        const maxLoops = args.maxLoops || 5;
+        const budget = args.budget;
+        const hasBudget = !!budget && (typeof budget.maxTurns === 'number' || typeof budget.maxCostUsd === 'number');
+        const mafwDir = path.join(projectDir, ".mafw");
+        const goalsDir = path.join(mafwDir, "goals");
+        const requestsDir = path.join(mafwDir, "requests");
+        fs.mkdirSync(goalsDir, { recursive: true });
+        fs.mkdirSync(requestsDir, { recursive: true });
+        const charterPath = path.join(goalsDir, `${goalId}.md`);
+        if (fs.existsSync(charterPath)) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: `Goal ${goalId} already exists` }) }], isError: true };
+        }
+        fs.writeFileSync(charterPath, charter, "utf-8");
+        const request = {
+            version: "2", goalId, title, state: "draft",
+            createdAt: new Date().toISOString(), confirmedAt: new Date().toISOString(),
+            source, projectDir, mafwDir, goalCharter: charterPath,
+            metrics, boundaries, priority, maxLoops, parallel: false,
+            degradeOnLoop: Math.ceil(maxLoops * 0.6),
+            ...(hasBudget ? { budget } : {}),
+        };
+        const requestPath = path.join(requestsDir, `${goalId}.json`);
+        fs.writeFileSync(requestPath, JSON.stringify(request, null, 2), "utf-8");
+        event_bus_1.eventBus.emit("goal_created", { type: "goal_created", goalId, projectDir });
+        return {
+            content: [{ type: "text", text: JSON.stringify({ success: true, goalId, charterPath, requestPath }) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleCreateGoal = handleCreateGoal;

package/gateway/dist/mcp/handlers/desktop-click.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopClick = void 0;
+const handleDesktopClick = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const selector = args.selector;
+        if (!selector)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "selector is required" }) }], isError: true };
+        const result = await desktop.click(selector);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopClick = handleDesktopClick;

package/gateway/dist/mcp/handlers/desktop-get-state.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopGetState = void 0;
+const handleDesktopGetState = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const result = await desktop.uiState();
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopGetState = handleDesktopGetState;

package/gateway/dist/mcp/handlers/desktop-navigate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopNavigate = void 0;
+const handleDesktopNavigate = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const tab = args.tab;
+        if (!tab)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "tab is required" }) }], isError: true };
+        const result = await desktop.navigate(tab);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopNavigate = handleDesktopNavigate;

package/gateway/dist/mcp/handlers/desktop-screenshot.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopScreenshot = void 0;
+const handleDesktopScreenshot = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const selector = args.selector;
+        const result = await desktop.screenshot(selector);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopScreenshot = handleDesktopScreenshot;

package/gateway/dist/mcp/handlers/desktop-scroll.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopScroll = void 0;
+const handleDesktopScroll = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const direction = args.direction;
+        const amount = args.amount;
+        if (!direction)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "direction is required (up/down/left/right)" }) }], isError: true };
+        const result = await desktop.scroll(direction, amount);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopScroll = handleDesktopScroll;

package/gateway/dist/mcp/handlers/desktop-type.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDesktopType = void 0;
+const handleDesktopType = async (args, { desktop }) => {
+    try {
+        if (!desktop)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Desktop not connected" }) }], isError: true };
+        const selector = args.selector;
+        const text = args.text;
+        if (!selector || text === undefined)
+            return { content: [{ type: "text", text: JSON.stringify({ error: "selector and text are required" }) }], isError: true };
+        const result = await desktop.type(selector, text);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleDesktopType = handleDesktopType;