@jack200714/mafw 4.5.1

package/gateway/dist/runtime/pi/pi-agent-config.js

@@ -0,0 +1,294 @@
+"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.getAgentDir = getAgentDir;
+exports.getPromptsDir = getPromptsDir;
+exports.getExtensionsDir = getExtensionsDir;
+exports.install = install;
+exports.remove = remove;
+exports.loadAgentExtensions = loadAgentExtensions;
+exports.list = list;
+exports.get = get;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Get the pi agent directory
+ */
+function getAgentDir(config) {
+    if (config?.agentDir)
+        return config.agentDir;
+    // Try to import pi's getAgentDir, fallback to default
+    try {
+        const piConfig = require('@earendil-works/pi-coding-agent/dist/config');
+        return piConfig.getAgentDir();
+    }
+    catch {
+        return path.join(process.env.HOME || process.env.USERPROFILE || '~', '.pi', 'agent');
+    }
+}
+/**
+ * Get the prompts directory
+ */
+function getPromptsDir(config) {
+    return path.join(getAgentDir(config), 'prompts');
+}
+/**
+ * Get the extensions directory
+ */
+function getExtensionsDir(config) {
+    return path.join(getAgentDir(config), 'extensions');
+}
+/**
+ * Get the metadata directory
+ */
+function getMetadataDir(config) {
+    return path.join(getAgentDir(config), 'metadata');
+}
+/**
+ * Install an agent definition into pi
+ */
+async function install(name, definition, config) {
+    const promptsDir = getPromptsDir(config);
+    const extensionsDir = getExtensionsDir(config);
+    const metadataDir = getMetadataDir(config);
+    // Ensure directories exist
+    fs.mkdirSync(promptsDir, { recursive: true });
+    fs.mkdirSync(extensionsDir, { recursive: true });
+    fs.mkdirSync(metadataDir, { recursive: true });
+    // Write system prompt
+    const promptPath = path.join(promptsDir, `${name}.md`);
+    fs.writeFileSync(promptPath, definition.systemPrompt, 'utf-8');
+    // Write permissions extension (pi ExtensionAPI format)
+    const extensionPath = path.join(extensionsDir, `${name}-permissions.js`);
+    const extensionCode = generatePermissionsExtension(name, definition.permissions);
+    fs.writeFileSync(extensionPath, extensionCode, 'utf-8');
+    // Write metadata for reliable round-trip
+    const metadataPath = path.join(metadataDir, `${name}.json`);
+    const metadata = {
+        description: definition.description,
+        mode: definition.mode,
+        model: definition.model,
+        temperature: definition.temperature,
+        color: definition.color,
+        permissions: definition.permissions,
+    };
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
+}
+/**
+ * Remove an agent definition from pi
+ */
+async function remove(name, config) {
+    const promptsDir = getPromptsDir(config);
+    const extensionsDir = getExtensionsDir(config);
+    const metadataDir = getMetadataDir(config);
+    const promptPath = path.join(promptsDir, `${name}.md`);
+    const extensionPath = path.join(extensionsDir, `${name}-permissions.js`);
+    const metadataPath = path.join(metadataDir, `${name}.json`);
+    if (fs.existsSync(promptPath)) {
+        fs.unlinkSync(promptPath);
+    }
+    if (fs.existsSync(extensionPath)) {
+        fs.unlinkSync(extensionPath);
+    }
+    if (fs.existsSync(metadataPath)) {
+        fs.unlinkSync(metadataPath);
+    }
+}
+/**
+ * Sanitize a name for use as a JavaScript function name
+ */
+function sanitizeFunctionName(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, '_');
+}
+/**
+ * Generate a pi extension that enforces permissions.
+ *
+ * Format: `export default function(pi) { pi.on('tool_call', handler) }`
+ * This matches pi's ExtensionFactory type: (pi: ExtensionAPI) => void | Promise<void>
+ */
+function generatePermissionsExtension(name, permissions) {
+    const editRule = permissions.edit || 'allow';
+    const bashRule = permissions.bash || 'allow';
+    // Build tool rules map (specific tool overrides)
+    const toolRules = {};
+    if (permissions.tools) {
+        Object.assign(toolRules, permissions.tools);
+    }
+    const funcName = sanitizeFunctionName(name);
+    const toolRulesJson = JSON.stringify(toolRules, null, 2);
+    const editRuleJson = JSON.stringify(editRule);
+    const bashRuleJson = JSON.stringify(bashRule);
+    const lines = [
+        `// Auto-generated permissions extension for agent: ${name}`,
+        `// Generated by MAFW gateway — pi ExtensionAPI format`,
+        `// ExtensionFactory: (pi: ExtensionAPI) => void`,
+        ``,
+        `export default function ${funcName}_permissions(pi) {`,
+        `  const toolRules = ${toolRulesJson};`,
+        ``,
+        `  pi.on('tool_call', async (event, ctx) => {`,
+        `    const toolName = event.toolName;`,
+        ``,
+        `    // Check specific tool rules first`,
+        `    if (toolRules[toolName]) {`,
+        `      const rule = toolRules[toolName];`,
+        `      if (rule === 'deny') {`,
+        `        return { block: true, reason: 'denied by agent permissions' };`,
+        `      }`,
+        `      if (rule === 'ask') {`,
+        `        return { block: true, reason: 'requires approval (not implemented)' };`,
+        `      }`,
+        `      // 'allow' — fall through to category checks`,
+        `    }`,
+        ``,
+        `    // Check category rules`,
+        `    if (toolName === 'edit' || toolName === 'write') {`,
+        `      const rule = ${editRuleJson};`,
+        `      if (rule === 'deny') {`,
+        `        return { block: true, reason: 'edit/write denied by agent permissions' };`,
+        `      }`,
+        `      if (rule === 'ask') {`,
+        `        return { block: true, reason: 'edit/write requires approval (not implemented)' };`,
+        `      }`,
+        `    }`,
+        ``,
+        `    if (toolName === 'bash') {`,
+        `      const rule = ${bashRuleJson};`,
+        `      if (rule === 'deny') {`,
+        `        return { block: true, reason: 'bash denied by agent permissions' };`,
+        `      }`,
+        `      if (rule === 'ask') {`,
+        `        return { block: true, reason: 'bash requires approval (not implemented)' };`,
+        `      }`,
+        `    }`,
+        ``,
+        `    // Default: allow`,
+        `    return { block: false };`,
+        `  });`,
+        `}`,
+        ``,
+    ];
+    return lines.join('\n');
+}
+/**
+ * Load agent-specific permission extensions from disk.
+ * Returns pi InlineExtension objects suitable for `resourceLoader.extensionFactories`.
+ *
+ * @param agentName - Agent name (e.g., 'manager')
+ * @param config - Optional pi agent config
+ * @returns Array of InlineExtension objects for createAgentSession
+ */
+async function loadAgentExtensions(agentName, config) {
+    const extensionsDir = getExtensionsDir(config);
+    const extensionPath = path.join(extensionsDir, `${agentName}-permissions.js`);
+    if (!fs.existsSync(extensionPath)) {
+        return [];
+    }
+    try {
+        // Dynamic import for ESM extension file
+        // Use file:// URL for Windows compatibility
+        const fileUrl = `file:///${extensionPath.replace(/\\/g, '/')}`;
+        const mod = await import(fileUrl);
+        const factory = mod.default;
+        if (typeof factory !== 'function') {
+            console.warn(`[PiAgentConfig] Extension ${agentName} does not export a default function`);
+            return [];
+        }
+        return [{
+                name: `${agentName}-permissions`,
+                factory,
+            }];
+    }
+    catch (err) {
+        console.warn(`[PiAgentConfig] Failed to load extension ${agentName}: ${err.message}`);
+        return [];
+    }
+}
+/**
+ * List installed agents
+ */
+async function list(config) {
+    const promptsDir = getPromptsDir(config);
+    if (!fs.existsSync(promptsDir)) {
+        return [];
+    }
+    const files = fs.readdirSync(promptsDir);
+    return files
+        .filter(f => f.endsWith('.md'))
+        .map(f => f.replace(/\.md$/, ''));
+}
+/**
+ * Get an agent definition (reads from metadata + prompt files for reliable round-trip)
+ */
+async function get(name, config) {
+    const promptsDir = getPromptsDir(config);
+    const promptPath = path.join(promptsDir, `${name}.md`);
+    if (!fs.existsSync(promptPath)) {
+        return null;
+    }
+    const systemPrompt = fs.readFileSync(promptPath, 'utf-8');
+    // Read metadata for round-trip fidelity
+    const metadataDir = getMetadataDir(config);
+    const metadataPath = path.join(metadataDir, `${name}.json`);
+    if (fs.existsSync(metadataPath)) {
+        try {
+            const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+            return {
+                description: metadata.description,
+                mode: metadata.mode || 'all',
+                model: metadata.model,
+                temperature: metadata.temperature,
+                color: metadata.color,
+                systemPrompt,
+                permissions: metadata.permissions,
+            };
+        }
+        catch (err) {
+            console.warn(`[PiAgentConfig] Failed to parse metadata for ${name}: ${err.message}`);
+        }
+    }
+    // Fallback: return basic definition without metadata
+    return {
+        description: `Agent: ${name}`,
+        mode: 'all',
+        systemPrompt,
+        permissions: {
+            edit: 'allow',
+            bash: 'allow',
+            tools: {},
+            task: {},
+        },
+    };
+}

package/gateway/dist/runtime/pi/pi-approval-bridge.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalBridge = void 0;
+class ApprovalBridge {
+    pending = new Map();
+    decisions = new Map();
+    timeoutMs;
+    constructor(timeoutMs = 300_000) {
+        this.timeoutMs = timeoutMs;
+    }
+    request(requestId) {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(requestId);
+                resolve(false);
+            }, this.timeoutMs);
+            this.pending.set(requestId, { resolve, timeout });
+        });
+    }
+    /** 三值回复；兼容旧 boolean 调用（true→once / false→reject）。 */
+    reply(requestId, decision, message) {
+        const req = this.pending.get(requestId);
+        if (!req)
+            return false;
+        const normalized = typeof decision === 'boolean' ? (decision ? 'once' : 'reject') : decision;
+        clearTimeout(req.timeout);
+        this.pending.delete(requestId);
+        this.decisions.set(requestId, { decision: normalized, message });
+        req.resolve(normalized !== 'reject');
+        return true;
+    }
+    /** extension 回查决策（always → 动态 allowlist；reject → block reason）。 */
+    lastDecision(requestId) {
+        return this.decisions.get(requestId) ?? null;
+    }
+    dispose() {
+        for (const { resolve, timeout } of this.pending.values()) {
+            clearTimeout(timeout);
+            resolve(false);
+        }
+        this.pending.clear();
+    }
+}
+exports.ApprovalBridge = ApprovalBridge;

package/gateway/dist/runtime/pi/pi-approval-extension.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMafwApprovalExtension = createMafwApprovalExtension;
+const crypto_1 = require("crypto");
+const DEFAULT_POLICY = {
+    autoApprove: ['read', 'grep', 'ls', 'find', 'glob'],
+    autoDeny: [],
+};
+function createMafwApprovalExtension(bridge, emitEvent, policy = DEFAULT_POLICY) {
+    return {
+        name: 'mafw-approval',
+        on: (emitter) => {
+            emitter.on('tool_call', async (event, ctx) => {
+                const toolName = event.toolName;
+                if (policy.autoApprove.includes(toolName)) {
+                    return;
+                }
+                if (policy.autoDeny.includes(toolName)) {
+                    return { block: true, reason: 'auto-denied by policy' };
+                }
+                const requestId = (0, crypto_1.randomUUID)();
+                const sessionID = ctx.sessionId;
+                emitEvent({
+                    payload: {
+                        type: 'permission.asked',
+                        properties: {
+                            sessionID,
+                            requestId,
+                            toolName,
+                            args: event.input,
+                            risk: 'medium',
+                        },
+                    },
+                });
+                const approved = await bridge.request(requestId);
+                const record = bridge.lastDecision(requestId);
+                const decision = record?.decision ?? (approved ? 'once' : 'reject');
+                const message = record?.message;
+                emitEvent({
+                    payload: {
+                        type: 'permission.replied',
+                        properties: {
+                            sessionID,
+                            requestId,
+                            approved,
+                            ...(decision !== 'once' ? { decision, ...(message ? { message } : {}) } : {}),
+                        },
+                    },
+                });
+                if (decision === 'always') {
+                    // session 级动态 allowlist：policy 是构造时共享引用，后续 tool_call 即时免审
+                    if (!policy.autoApprove.includes(toolName))
+                        policy.autoApprove.push(toolName);
+                    return;
+                }
+                if (!approved) {
+                    return { block: true, reason: message || 'rejected by user' };
+                }
+            });
+        },
+    };
+}

package/gateway/dist/runtime/pi/pi-events.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiEventStream = void 0;
+exports.translatePiEvent = translatePiEvent;
+function translatePiEvent(event, sessionID) {
+    const t = event?.type ?? event?.payload?.type;
+    const prop = (extra = {}) => ({ payload: { type: 'message.part.updated', properties: { part: { sessionID, ...extra } } } });
+    switch (t) {
+        case 'agent_start':
+            return { payload: { type: 'session.updated', properties: { sessionID } } };
+        case 'message_start':
+        case 'message_update':
+            return { payload: { type: 'message.part.updated', properties: { part: { sessionID, type: 'text', text: event?.delta ?? '' } } } };
+        case 'message_end':
+            return { payload: { type: 'message.updated', properties: { sessionID, info: { role: 'assistant' } } } };
+        case 'tool_call':
+            return prop({ type: 'tool-call' });
+        case 'tool_result':
+            return prop({ type: 'tool-result' });
+        case 'turn_start':
+            return prop({ type: 'step-start' });
+        case 'turn_end':
+            return prop({ type: 'step-finish', assistantMessageID: `pi_step_${sessionID}` });
+        case 'agent_end':
+        case 'agent_settled':
+            return { payload: { type: 'session.idle', properties: { sessionID } } };
+        case 'permission.asked':
+            return {
+                payload: {
+                    type: 'permission.asked',
+                    properties: {
+                        sessionID: event.payload.properties.sessionID,
+                        requestId: event.payload.properties.requestId,
+                        toolName: event.payload.properties.toolName,
+                        args: event.payload.properties.args,
+                        risk: event.payload.properties.risk,
+                    },
+                },
+            };
+        case 'permission.replied':
+            return {
+                payload: {
+                    type: 'permission.replied',
+                    properties: {
+                        sessionID: event.payload.properties.sessionID,
+                        requestId: event.payload.properties.requestId,
+                        approved: event.payload.properties.approved,
+                    },
+                },
+            };
+        default:
+            return null;
+    }
+}
+class PiEventStream {
+    resolveSessionId;
+    listeners = new Set();
+    subscribed = false;
+    onEvent = null;
+    constructor(resolveSessionId) {
+        this.resolveSessionId = resolveSessionId;
+    }
+    /** 单例底层订阅：registry 在 create 时经 trackSession 挂订阅。 */
+    attach() {
+        if (this.subscribed)
+            return;
+        this.subscribed = true;
+        this.onEvent = (evt) => {
+            const id = this.resolveSessionId(evt?.session);
+            if (!id)
+                return;
+            const translated = translatePiEvent(evt, id);
+            if (translated) {
+                for (const l of this.listeners)
+                    l(translated);
+            }
+        };
+    }
+    /** 新会话登记时挂订阅（PiSessionRegistry.create 经回调调用）。 */
+    trackSession(session) {
+        if (typeof session?.subscribe !== 'function')
+            return;
+        this.attach();
+        session.subscribe(this.onEvent);
+    }
+    /** 返回新 AsyncIterable，fan-out 共享底层 listener。 */
+    stream() {
+        const listeners = this.listeners;
+        const queue = [];
+        const waiters = [];
+        const listener = (evt) => {
+            const w = waiters.shift();
+            if (w)
+                w(evt);
+            else
+                queue.push(evt);
+        };
+        listeners.add(listener);
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    next: async () => {
+                        if (queue.length)
+                            return { value: queue.shift(), done: false };
+                        return new Promise((resolve) => waiters.push((v) => resolve({ value: v, done: false })));
+                    },
+                    return: async () => { listeners.delete(listener); return { done: true, value: undefined }; },
+                };
+            },
+        };
+    }
+    push(event) {
+        for (const l of this.listeners)
+            l(event);
+    }
+    async dispose() {
+        this.listeners.clear();
+        this.subscribed = false;
+        this.onEvent = null;
+    }
+}
+exports.PiEventStream = PiEventStream;

package/gateway/dist/runtime/pi/pi-messages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translatePiMessages = translatePiMessages;
+exports.piMessagesToParts = piMessagesToParts;
+function translatePiMessages(messages, sessionID) {
+    return messages.map((m, i) => ({
+        id: `pimsg_${sessionID}_${i}`,
+        role: m?.role === 'assistant' ? 'assistant' : 'user',
+        content: (m?.content || [])
+            .filter((c) => c?.type === 'text' && typeof c?.text === 'string')
+            .map((c) => ({ type: 'text', text: c.text })),
+        sessionID,
+        time: { created: m?.timestamp ?? Date.now(), updated: m?.timestamp ?? Date.now() },
+    }));
+}
+function piMessagesToParts(messages) {
+    return (messages || [])
+        .flatMap((m) => (m?.content || []).filter((c) => c?.type === 'text' && typeof c?.text === 'string'))
+        .map((c) => ({ type: 'text', text: c.text }));
+}

package/gateway/dist/runtime/pi/pi-provider.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateProviders = translateProviders;
+exports.translateAgents = translateAgents;
+exports.translateConfigGet = translateConfigGet;
+exports.translateConfigUpdate = translateConfigUpdate;
+async function translateProviders(mr) {
+    const providers = (mr?.getProviders?.() || []);
+    const all = providers.map((p) => ({
+        id: p?.id,
+        name: p?.name ?? p?.id,
+        models: (mr?.getModels?.(p?.id) || []).map((m) => ({ id: m?.id, name: m?.id })),
+    }));
+    const connected = providers.filter((p) => mr?.hasConfiguredAuth?.(p?.id) ?? false).map((p) => p?.id);
+    return { all, connected, default: {} };
+}
+async function translateAgents() { return []; }
+async function translateConfigGet() { return {}; }
+async function translateConfigUpdate(cfg) { return cfg; }

package/gateway/dist/runtime/pi/pi-session-storage.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPiSessionToGateway = mapPiSessionToGateway;
+exports.listByDirectory = listByDirectory;
+/**
+ * 将 pi 的 SessionInfo 映射为 gateway 的 SessionInfo 格式
+ */
+function mapPiSessionToGateway(pi) {
+    return {
+        id: pi.id,
+        projectID: pi.cwd || '',
+        directory: pi.cwd || '',
+        title: pi.name || pi.firstMessage || pi.id,
+        time: {
+            created: pi.created?.getTime?.() ?? 0,
+            updated: pi.modified?.getTime?.() ?? 0,
+        },
+    };
+}
+/**
+ * 按目录列出持久化会话（从 pi 的 SessionManager.list 读取）
+ *
+ * @param directory - 工作目录（cwd）
+ * @param limit - 可选，限制返回数量
+ * @param piModule - 可选，已加载的 pi SDK 模块（用于测试注入）
+ * @returns gateway SessionInfo 数组
+ */
+async function listByDirectory(directory, limit, piModule) {
+    try {
+        // 动态导入 pi SDK（ESM-only）或使用注入的模块
+        const mod = piModule ?? await import('@earendil-works/pi-coding-agent');
+        if (!mod?.SessionManager)
+            return [];
+        // 调用 pi 的 SessionManager.list(cwd)
+        const sessions = await mod.SessionManager.list(directory);
+        // 映射格式
+        const mapped = sessions.map(mapPiSessionToGateway);
+        // 应用 limit
+        return limit ? mapped.slice(0, limit) : mapped;
+    }
+    catch {
+        return [];
+    }
+}