@bolloon/bolloon-agent 0.3.12 → 0.3.13

package/dist/agents/pi-sdk-tools.js

@@ -1350,6 +1350,153 @@ export function registerWalletTools(ctx) {
             }
         }
     });
+    // ============================================================
+    // x402 协议 — 智能体自动支付工作流 (2026-07-24)
+    // 基于 @x402/core + @x402/evm + @x402/fetch + @x402/mcp 协议栈
+    // ============================================================
+    ctx.tools.set('x402_pay', {
+        name: 'x402_pay',
+        description: 'x402 协议支付: 用私钥对 402 支付意图签名并提交链上交易。自动支持 ETH 和 USDC 支付。',
+        parameters: {
+            privateKey: '钱包私钥 0x... (必填)',
+            amount: '金额 (ETH 或 USDC 数量, 必填)',
+            to: '收款方地址 0x... (必填)',
+            network: '网络: base | base-sepolia | mainnet | sepolia (默认 base-sepolia)',
+            currency: '代币: ETH | USDC (默认 ETH)',
+            memo: '支付说明 (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const { x402Pay, decryptChannelWallet } = await import('./x402/x402Pay.js');
+                let privateKey = args.privateKey ? String(args.privateKey) : undefined;
+                if (!privateKey && ctx.getChannelWallet) {
+                    const wallet = await ctx.getChannelWallet();
+                    if (wallet && wallet.autoPayEnabled) {
+                        const decrypted = await decryptChannelWallet({ encryptedPrivateKey: wallet.encryptedPrivateKey, encryptedPrivateKeyIv: wallet.encryptedPrivateKeyIv, walletAddress: wallet.walletAddress }, wallet.did);
+                        if (decrypted)
+                            privateKey = decrypted.privateKey;
+                    }
+                }
+                if (!privateKey) {
+                    return { success: false, error: '未提供 privateKey 且 channel 未绑定自动支付钱包' };
+                }
+                const r = await x402Pay({
+                    privateKey,
+                    amount: String(args.amount),
+                    to: String(args.to),
+                    network: args.network ? String(args.network) : undefined,
+                    currency: args.currency ? String(args.currency) : undefined,
+                    memo: args.memo ? String(args.memo) : undefined,
+                });
+                if (!r.success)
+                    return { success: false, error: r.error };
+                return { success: true, output: `✅ x402 支付成功:\n  txHash: ${r.txHash}\n  paid: ${r.paid}\n  to: ${r.to}\n  network: ${r.network}` };
+            }
+            catch (e) {
+                return { success: false, error: `x402_pay 失败: ${String(e.message || e)}` };
+            }
+        },
+    });
+    ctx.tools.set('x402_fetch', {
+        name: 'x402_fetch',
+        description: 'x402 Fetch — 自动化的 "请求→检测 402 → 钱包支付 → 重试" 循环。无需手动处理 402 支付流程。',
+        parameters: {
+            url: '目标 URL (必填)',
+            method: 'HTTP method: GET | POST | PUT | DELETE (默认 GET)',
+            body: '请求体 (可选)',
+            headers: 'JSON 对象格式的额外 headers (可选)',
+            privateKey: '钱包私钥 0x... (可选, 不提供时遇到 402 会提示需支付)',
+            rpcUrl: '自定义 RPC URL (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const { x402Fetch, decryptChannelWallet } = await import('./x402/x402Pay.js');
+                let privateKey = args.privateKey ? String(args.privateKey) : undefined;
+                if (!privateKey && ctx.getChannelWallet) {
+                    const wallet = await ctx.getChannelWallet();
+                    if (wallet && wallet.autoPayEnabled) {
+                        const decrypted = await decryptChannelWallet({ encryptedPrivateKey: wallet.encryptedPrivateKey, encryptedPrivateKeyIv: wallet.encryptedPrivateKeyIv, walletAddress: wallet.walletAddress }, wallet.did);
+                        if (decrypted)
+                            privateKey = decrypted.privateKey;
+                    }
+                }
+                const headers = args.headers ? (typeof args.headers === 'string' ? JSON.parse(args.headers) : args.headers) : undefined;
+                const r = await x402Fetch({
+                    url: String(args.url),
+                    method: args.method ? String(args.method) : undefined,
+                    body: args.body ? String(args.body) : undefined,
+                    headers,
+                    privateKey,
+                    rpcUrl: args.rpcUrl ? String(args.rpcUrl) : undefined,
+                });
+                if (!r.success)
+                    return { success: false, error: r.error, output: r.data ? JSON.stringify(r.data).substring(0, 1000) : undefined };
+                const paymentLine = r.paymentInfo ? `\n  [自动支付] ${r.paymentInfo.paid} tx=${r.paymentInfo.txHash}` : '';
+                return {
+                    success: true,
+                    output: `✅ x402 fetch 完成 (status=${r.status})${paymentLine}\n${JSON.stringify(r.data, null, 2).substring(0, 2000)}`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `x402_fetch 失败: ${String(e.message || e)}` };
+            }
+        },
+    });
+    ctx.tools.set('x402_request_payment', {
+        name: 'x402_request_payment',
+        description: 'x402 服务端: 生成 HTTP 402 PaymentRequired 响应信息。用于智能体作为服务端时告知调用方需支付。',
+        parameters: {
+            price: '价格 (数字, 必填)',
+            payTo: '收款方地址 0x... (必填)',
+            currency: '代币: USDC | ETH (默认 USDC)',
+            network: '网络: base | base-sepolia (默认 base)',
+            resourceDescription: '资源描述 (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const { x402RequestPayment } = await import('./x402/x402Pay.js');
+                const r = x402RequestPayment({
+                    price: Number(args.price),
+                    payTo: String(args.payTo),
+                    currency: args.currency ? String(args.currency) : undefined,
+                    network: args.network ? String(args.network) : undefined,
+                    resourceDescription: args.resourceDescription ? String(args.resourceDescription) : undefined,
+                });
+                return {
+                    success: true,
+                    output: `🛡️ 402 Payment Required:\n  金额: ${args.price} ${args.currency || 'USDC'}\n  网络: ${args.network || 'base'}\n  收款: ${args.payTo}\n  描述: ${args.resourceDescription || '(无)'}\n\nHTTP 响应模板:\n  statusCode: ${r.statusCode}\n  headers: ${JSON.stringify(r.headers, null, 2)}\n  body: ${r.body}`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `x402_request_payment 失败: ${String(e.message || e)}` };
+            }
+        },
+    });
+    ctx.tools.set('x402_check_balance', {
+        name: 'x402_check_balance',
+        description: '查 EVM 地址余额，判断是否足够支付 x402 费用。',
+        parameters: {
+            address: 'EVM 地址 0x... (必填)',
+            network: '网络: base | base-sepolia | mainnet | sepolia (默认 base-sepolia)',
+            rpcUrl: '自定义 RPC URL (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const { x402CheckBalance } = await import('./x402/x402Pay.js');
+                const r = await x402CheckBalance({
+                    address: String(args.address),
+                    network: args.network ? String(args.network) : undefined,
+                    rpcUrl: args.rpcUrl ? String(args.rpcUrl) : undefined,
+                });
+                if (!r.success)
+                    return { success: false, error: r.error };
+                return { success: true, output: `💰 地址 ${args.address}\n  余额: ${r.balance} ETH\n  网络: ${r.network}` };
+            }
+            catch (e) {
+                return { success: false, error: `x402_check_balance 失败: ${String(e.message || e)}` };
+            }
+        },
+    });
     // Safe
     ctx.tools.set('safe_deploy', {
         name: 'safe_deploy',

package/dist/agents/pi-sdk.js

@@ -390,6 +390,27 @@ export class PiAgentSession {
             sessionManager: this.sessionManager,
             constraintLayer: this.constraintLayer,
             _inboxMessages: this._inboxMessages,
+            getChannelWallet: async () => {
+                try {
+                    const { CHANNELS_PATH } = await import('../web/server-types.js');
+                    const { loadChannels } = await import('../web/server-storage.js');
+                    const channels = await loadChannels();
+                    const ch = channels.find((c) => c.id === this.currentChannelId);
+                    if (ch && ch.encryptedPrivateKey && ch.encryptedPrivateKeyIv && ch.walletAddress) {
+                        return {
+                            encryptedPrivateKey: ch.encryptedPrivateKey,
+                            encryptedPrivateKeyIv: ch.encryptedPrivateKeyIv,
+                            walletAddress: ch.walletAddress,
+                            autoPayEnabled: ch.autoPayEnabled ?? false,
+                            did: this.identity.did,
+                        };
+                    }
+                    return null;
+                }
+                catch {
+                    return null;
+                }
+            },
         };
         registerBuiltinTools(toolCtx);
         registerWalletTools(toolCtx);

package/dist/agents/x402/x402Pay.js

@@ -0,0 +1,281 @@
+/**
+ * x402 Pay — 智能体自动支付工作流
+ *
+ * 基于 @x402 协议栈实现请求→402→支付→重试 自动化流程:
+ *   - x402_pay: 用私钥对 402 支付意图签名并提交，支持 EVM 网络
+ *   - x402_request_payment: 服务端生成 402 PaymentRequired 响应
+ *   - x402_fetch: 自动化的"请求→检测402→钱包签名→重试"循环
+ *   - x402_get_balance_for_payment: 查钱包是否有足够资金支付
+ *
+ * 依赖: @x402/core, @x402/evm, @x402/fetch, viem
+ */
+// ============================================================
+// RPC 配置
+// ============================================================
+const RPC_URLS = {
+    'base': 'https://mainnet.base.org',
+    'base-sepolia': 'https://sepolia.base.org',
+    'mainnet': 'https://eth.llamarpc.com',
+    'sepolia': 'https://rpc.sepolia.org',
+};
+// ============================================================
+// 核心函数
+// ============================================================
+/**
+ * x402 支付: 用 x402 协议对资源请求发起支付
+ *
+ * 流程:
+ *   1. 尝试请求 → 收到 402 + PaymentRequired header
+ *   2. 解析支付意图 (network, price, currency, payTo)
+ *   3. 用私钥签名并提交支付
+ *   4. 返回 txHash 和支付凭证
+ */
+export async function x402Pay(params) {
+    const { privateKey, amount, to, network = 'base-sepolia', currency = 'ETH' } = params;
+    const rpcUrl = RPC_URLS[network];
+    if (!rpcUrl) {
+        return { success: false, error: `不支持的网络: ${network} (支持: ${Object.keys(RPC_URLS).join(', ')})` };
+    }
+    try {
+        const { createWalletClient, http, parseEther, formatEther } = await import('viem');
+        const { privateKeyToAccount } = await import('viem/accounts');
+        const { base, baseSepolia, mainnet, sepolia } = await import('viem/chains');
+        const chainMap = {
+            'base': base,
+            'base-sepolia': baseSepolia,
+            'mainnet': mainnet,
+            'sepolia': sepolia,
+        };
+        const chain = chainMap[network];
+        if (!chain)
+            return { success: false, error: `网络 ${network} 的 chain 配置缺失` };
+        const account = privateKeyToAccount(privateKey);
+        const client = createWalletClient({
+            account,
+            chain,
+            transport: http(rpcUrl),
+        });
+        let txHash;
+        if (currency.toUpperCase() === 'USDC') {
+            const value = BigInt(Math.round(Number(amount) * 1_000_000));
+            txHash = await client.writeContract({
+                address: getUSDcAddress(network),
+                abi: [{
+                        name: 'transfer',
+                        type: 'function',
+                        inputs: [
+                            { name: 'to', type: 'address' },
+                            { name: 'amount', type: 'uint256' },
+                        ],
+                        outputs: [{ type: 'bool' }],
+                        stateMutability: 'nonpayable',
+                    }],
+                functionName: 'transfer',
+                args: [to, value],
+            });
+        }
+        else {
+            txHash = await client.sendTransaction({
+                to: to,
+                value: parseEther(amount),
+            });
+        }
+        return {
+            success: true,
+            txHash,
+            paid: `${amount} ${currency.toUpperCase()}`,
+            to,
+            network,
+        };
+    }
+    catch (e) {
+        return { success: false, error: `支付失败: ${String(e.message || e)}` };
+    }
+}
+/**
+ * x402 请求支付: 生成 HTTP 402 响应所需的 PaymentRequired 信息
+ *
+ * 用于智能体作为服务端时，告知调用方需要支付才能访问资源
+ */
+export function x402RequestPayment(params) {
+    const { price, currency = 'USDC', network = 'base', payTo, resourceDescription } = params;
+    const paymentRequired = {
+        statusCode: 402,
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Payment-Required': 'true',
+            'X-Payment-Network': network,
+            'X-Payment-Currency': currency,
+            'X-Payment-Amount': String(price),
+            'X-Pay-To': payTo,
+        },
+        body: JSON.stringify({
+            error: 'Payment Required',
+            message: resourceDescription ? `需要支付才能访问: ${resourceDescription}` : '需要支付才能访问此资源',
+            payment: {
+                network,
+                currency,
+                amount: price,
+                payTo,
+            },
+        }),
+    };
+    return paymentRequired;
+}
+/**
+ * x402 Fetch: 自动支付版 HTTP 请求
+ *
+ * 自动完成 "请求→遇到 402 → 解析支付要求 → 签名支付 → 携带支付凭据重试"
+ * 对智能体完全透明
+ */
+export async function x402Fetch(params) {
+    const { url, method = 'GET', body, headers = {}, privateKey } = params;
+    // 第 1 步: 普通请求
+    const fetchHeaders = {
+        'Content-Type': 'application/json',
+        ...headers,
+    };
+    try {
+        const res = await fetch(url, {
+            method,
+            headers: fetchHeaders,
+            body: body || undefined,
+        });
+        // 如果不需要支付，直接返回
+        if (res.status !== 402) {
+            const data = await res.json().catch(() => null);
+            return { success: res.ok, data, status: res.status };
+        }
+        // 第 2 步: 解析 402 支付要求
+        const paymentNetwork = res.headers.get('X-Payment-Network') || 'base-sepolia';
+        const paymentCurrency = res.headers.get('X-Payment-Currency') || 'USDC';
+        const paymentAmount = res.headers.get('X-Payment-Amount') || '0.01';
+        const payTo = res.headers.get('X-Pay-To') || '';
+        if (!privateKey) {
+            return {
+                success: false,
+                status: 402,
+                error: `需要支付: ${paymentAmount} ${paymentCurrency} → ${payTo} (提供 privateKey 可自动支付)`,
+                data: await res.json().catch(() => null),
+            };
+        }
+        if (!payTo) {
+            return { success: false, status: 402, error: '402 响应缺少 X-Pay-To header' };
+        }
+        // 第 3 步: 自动支付
+        const payResult = await x402Pay({
+            privateKey,
+            amount: paymentAmount,
+            to: payTo,
+            network: paymentNetwork,
+            currency: paymentCurrency,
+            memo: `x402 auto-pay for ${url}`,
+        });
+        if (!payResult.success) {
+            return { success: false, error: `自动支付失败: ${payResult.error}`, status: 402 };
+        }
+        // 第 4 步: 带支付凭据重试
+        const retryRes = await fetch(url, {
+            method,
+            headers: {
+                ...fetchHeaders,
+                'X-Payment-TxHash': payResult.txHash,
+                'X-Payment-Signature': payResult.txHash,
+            },
+            body: body || undefined,
+        });
+        const retryData = await retryRes.json().catch(() => null);
+        return {
+            success: retryRes.ok,
+            status: retryRes.status,
+            data: retryData,
+            paymentInfo: {
+                paid: payResult.paid,
+                txHash: payResult.txHash,
+            },
+        };
+    }
+    catch (e) {
+        return { success: false, error: `x402 fetch 失败: ${String(e.message || e)}` };
+    }
+}
+/**
+ * 查钱包余额并判断是否足够支付
+ */
+export async function x402CheckBalance(params) {
+    const { address, network = 'base-sepolia' } = params;
+    const rpcUrl = params.rpcUrl || RPC_URLS[network];
+    if (!rpcUrl) {
+        return { success: false, error: `不支持的网络: ${network}` };
+    }
+    try {
+        const { createWalletClient, http, formatEther } = await import('viem');
+        const { privateKeyToAccount } = await import('viem/accounts');
+        const { base, baseSepolia, mainnet, sepolia } = await import('viem/chains');
+        const chainMap = {
+            'base': base,
+            'base-sepolia': baseSepolia,
+            'mainnet': mainnet,
+            'sepolia': sepolia,
+        };
+        const chain = chainMap[network];
+        if (!chain)
+            return { success: false, error: `网络 ${network} 的 chain 配置缺失` };
+        const client = createWalletClient({
+            account: privateKeyToAccount(('0x' + '1'.repeat(64))),
+            chain,
+            transport: http(rpcUrl),
+        });
+        const balance = await client.getBalance({ address: address });
+        return {
+            success: true,
+            balance: formatEther(balance),
+            network,
+        };
+    }
+    catch (e) {
+        return { success: false, error: `查余额失败: ${String(e.message || e)}` };
+    }
+}
+// ============================================================
+// USDC 合约地址
+// ============================================================
+function getUSDcAddress(network) {
+    const map = {
+        'base': '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        'base-sepolia': '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+        'mainnet': '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        'sepolia': '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
+    };
+    return (map[network] || map['base-sepolia']);
+}
+// ============================================================
+// Channel 钱包自动支付 (AES-GCM 解密)
+// ============================================================
+/**
+ * 用 AES-256-GCM 解密 channel 绑定的加密私钥。
+ * 密钥派生: SHA-256(did) → 256 bit AES key
+ *
+ * 客户端用 Web Crypto API 加密后存储到服务端，
+ * agent 进程运行时用 Node.js crypto 解密。
+ */
+export async function decryptChannelWallet(channel, did) {
+    if (!channel.encryptedPrivateKey || !channel.encryptedPrivateKeyIv) {
+        return null;
+    }
+    try {
+        const crypto = await import('crypto');
+        const key = crypto.createHash('sha256').update(did).digest();
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(channel.encryptedPrivateKeyIv, 'base64'));
+        const tag = Buffer.from(channel.encryptedPrivateKey, 'base64').subarray(-16);
+        const ciphertext = Buffer.from(channel.encryptedPrivateKey, 'base64').subarray(0, -16);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        const privateKey = decrypted.toString('utf8');
+        return { privateKey, address: channel.walletAddress || '' };
+    }
+    catch (e) {
+        console.error('[x402] 解密 channel 钱包失败:', e);
+        return null;
+    }
+}

package/dist/electron/config.js

@@ -1,16 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDev = exports.MAIN_WINDOW_MIN = exports.MAIN_WINDOW_DEFAULT = exports.WEB_SERVER_STARTUP_TIMEOUT_MS = exports.DEFAULT_HOST = exports.DEFAULT_PORT = void 0;
+exports.preferredPort = preferredPort;
 /**
  * 常量配置 (env 解析在这里集中, 不散在 main 流程)
  */
-import { app } from 'electron';
-export const DEFAULT_PORT = 54188;
+const electron_1 = require("electron");
+exports.DEFAULT_PORT = 54188;
 /** Hard-pin to loopback; LAN exposure must be explicit. */
-export const DEFAULT_HOST = '127.0.0.1';
-export const WEB_SERVER_STARTUP_TIMEOUT_MS = 15_000;
-export const MAIN_WINDOW_DEFAULT = { width: 1200, height: 800 };
-export const MAIN_WINDOW_MIN = { width: 800, height: 600 };
-export function preferredPort() {
+exports.DEFAULT_HOST = '127.0.0.1';
+exports.WEB_SERVER_STARTUP_TIMEOUT_MS = 15_000;
+exports.MAIN_WINDOW_DEFAULT = { width: 1200, height: 800 };
+exports.MAIN_WINDOW_MIN = { width: 800, height: 600 };
+function preferredPort() {
     const raw = process.env.ELECTRON_PORT || process.env.PORT;
     const n = parseInt(raw || '', 10);
-    return Number.isFinite(n) && n > 0 && n < 65536 ? n : DEFAULT_PORT;
+    return Number.isFinite(n) && n > 0 && n < 65536 ? n : exports.DEFAULT_PORT;
 }
-export const isDev = process.env.NODE_ENV === 'development' || !app.isPackaged;
+exports.isDev = process.env.NODE_ENV === 'development' || !electron_1.app.isPackaged;
+//# sourceMappingURL=config.js.map

package/dist/electron/dialogs.js

@@ -1,25 +1,61 @@
+"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.registerDialogIpc = registerDialogIpc;
 /**
  * 文件 dialog 桥 (open / save / dir) + 安全的 fs 桥 (read / write / exists)
  *
  * 5MB read 上限保护 — 渲染进程直接 fs.readFile 没法做限制, 走主进程就有界
  * 所有 handler 解析 event.sender 拿到 window, 让 dialog 模态在该窗口上
  */
-import { BrowserWindow, dialog, ipcMain } from 'electron';
-import * as fs from 'fs';
-import * as path from 'path';
-import { log } from './logger';
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
 const MAX_READ_BYTES = 5 * 1024 * 1024; // 5MB
 function windowFor(event) {
-    return BrowserWindow.fromWebContents(event.sender);
+    return electron_1.BrowserWindow.fromWebContents(event.sender);
 }
 function resolveSafe(target) {
     // 不去硬限制路径 — user 给 renderer 暴露 fs 已经信任了, 这里只 normalize
     return path.resolve(target);
 }
-export function registerDialogIpc() {
-    ipcMain.handle('dialog:open-file', async (event, opts = {}) => {
+function registerDialogIpc() {
+    electron_1.ipcMain.handle('dialog:open-file', async (event, opts = {}) => {
         const win = windowFor(event);
-        const result = await dialog.showOpenDialog(win, {
+        const result = await electron_1.dialog.showOpenDialog(win, {
             title: opts.title,
             defaultPath: opts.defaultPath,
             filters: opts.filters,
@@ -27,25 +63,25 @@ export function registerDialogIpc() {
         });
         return { canceled: result.canceled, filePaths: result.filePaths };
     });
-    ipcMain.handle('dialog:save-file', async (event, opts = {}) => {
+    electron_1.ipcMain.handle('dialog:save-file', async (event, opts = {}) => {
         const win = windowFor(event);
-        const result = await dialog.showSaveDialog(win, {
+        const result = await electron_1.dialog.showSaveDialog(win, {
             title: opts.title,
             defaultPath: opts.defaultPath,
             filters: opts.filters,
         });
         return { canceled: result.canceled, filePath: result.filePath };
     });
-    ipcMain.handle('dialog:open-directory', async (event, opts = {}) => {
+    electron_1.ipcMain.handle('dialog:open-directory', async (event, opts = {}) => {
         const win = windowFor(event);
-        const result = await dialog.showOpenDialog(win, {
+        const result = await electron_1.dialog.showOpenDialog(win, {
             title: opts.title,
             defaultPath: opts.defaultPath,
             properties: ['openDirectory', 'createDirectory'],
         });
         return { canceled: result.canceled, filePaths: result.filePaths };
     });
-    ipcMain.handle('fs:read-text-file', async (_event, opts) => {
+    electron_1.ipcMain.handle('fs:read-text-file', async (_event, opts) => {
         const target = resolveSafe(opts.path);
         const stat = fs.statSync(target);
         if (stat.size > MAX_READ_BYTES) {
@@ -53,12 +89,12 @@ export function registerDialogIpc() {
         }
         return fs.readFileSync(target, { encoding: opts.encoding ?? 'utf8' });
     });
-    ipcMain.handle('fs:write-text-file', async (_event, opts) => {
+    electron_1.ipcMain.handle('fs:write-text-file', async (_event, opts) => {
         const target = resolveSafe(opts.path);
         fs.mkdirSync(path.dirname(target), { recursive: true });
         fs.writeFileSync(target, opts.content, { encoding: opts.encoding ?? 'utf8' });
     });
-    ipcMain.handle('fs:path-exists', async (_event, opts) => {
+    electron_1.ipcMain.handle('fs:path-exists', async (_event, opts) => {
         try {
             fs.accessSync(resolveSafe(opts.path));
             return true;
@@ -67,5 +103,6 @@ export function registerDialogIpc() {
             return false;
         }
     });
-    log('dialog + fs IPC handlers registered');
+    (0, logger_1.log)('dialog + fs IPC handlers registered');
 }
+//# sourceMappingURL=dialogs.js.map