@lynker-desktop/electron-sdk 0.0.9-alpha.7 → 0.0.9-alpha.72

package/main/clipboard.js

@@ -0,0 +1,1208 @@
+const electron = require('electron');
+const fs = require('node:fs');
+const path = require('node:path');
+const http = require('node:http');
+const https = require('node:https');
+const ipc = require('@lynker-desktop/electron-ipc/main');
+
+// 常量定义
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB，超过此大小不读取 buffer
+const FILE_URI_PREFIX = 'file://';
+const PLATFORM = process.platform;
+const DOWNLOAD_TIMEOUT = 30000; // 30秒下载超时
+const UNIX_FILE_FORMATS = ['public.file-url', 'text/uri-list', 'x-special/gnome-copied-files'];
+// 图片相关的剪贴板格式
+const IMAGE_FORMATS = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/bmp', 'image/webp', 'image/tiff', 'image/x-png', 'image/x-icon'];
+// Windows 文件格式
+const WINDOWS_FILE_FORMAT = 'FileNameW';
+// MIME 类型映射表
+const MIME_TYPES = {
+    // 文本文件
+    '.txt': 'text/plain',
+    '.text': 'text/plain',
+    '.md': 'text/markdown',
+    '.markdown': 'text/markdown',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.jsx': 'text/javascript',
+    '.ts': 'text/typescript',
+    '.tsx': 'text/typescript',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+    '.csv': 'text/csv',
+    '.rtf': 'application/rtf',
+    '.log': 'text/plain',
+    // 图片文件
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff',
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.avif': 'image/avif',
+    // 音频文件
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.oga': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.aac': 'audio/aac',
+    '.flac': 'audio/flac',
+    '.wma': 'audio/x-ms-wma',
+    '.opus': 'audio/opus',
+    '.amr': 'audio/amr',
+    // 视频文件
+    '.mp4': 'video/mp4',
+    '.avi': 'video/x-msvideo',
+    '.mov': 'video/quicktime',
+    '.wmv': 'video/x-ms-wmv',
+    '.flv': 'video/x-flv',
+    '.webm': 'video/webm',
+    '.mkv': 'video/x-matroska',
+    '.m4v': 'video/mp4',
+    '.3gp': 'video/3gpp',
+    '.ogv': 'video/ogg',
+    '.m2ts': 'video/mp2t',
+    '.mts': 'video/mp2t',
+    // 文档文件
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.odt': 'application/vnd.oasis.opendocument.text',
+    '.ods': 'application/vnd.oasis.opendocument.spreadsheet',
+    '.odp': 'application/vnd.oasis.opendocument.presentation',
+    // 压缩文件
+    '.zip': 'application/zip',
+    '.rar': 'application/x-rar-compressed',
+    '.7z': 'application/x-7z-compressed',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.bz2': 'application/x-bzip2',
+    '.xz': 'application/x-xz',
+    // 字体文件
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.eot': 'application/vnd.ms-fontobject',
+    // 代码文件
+    '.c': 'text/x-c',
+    '.cpp': 'text/x-c++',
+    '.h': 'text/x-c',
+    '.hpp': 'text/x-c++',
+    '.java': 'text/x-java-source',
+    '.py': 'text/x-python',
+    '.rb': 'text/x-ruby',
+    '.php': 'text/x-php',
+    '.go': 'text/x-go',
+    '.rs': 'text/x-rust',
+    '.swift': 'text/x-swift',
+    '.kt': 'text/x-kotlin',
+    '.scala': 'text/x-scala',
+    '.sh': 'application/x-sh',
+    '.bash': 'application/x-sh',
+    '.zsh': 'application/x-sh',
+    '.ps1': 'application/x-powershell',
+    '.bat': 'application/x-msdos-program',
+    '.cmd': 'application/x-msdos-program',
+    // 数据文件
+    '.db': 'application/x-sqlite3',
+    '.sqlite': 'application/x-sqlite3',
+    '.sql': 'application/sql',
+    // 其他
+    '.exe': 'application/x-msdownload',
+    '.dll': 'application/x-msdownload',
+    '.so': 'application/x-sharedlib',
+    '.dylib': 'application/x-mach-binary',
+    '.deb': 'application/vnd.debian.binary-package',
+    '.rpm': 'application/x-rpm',
+    '.apk': 'application/vnd.android.package-archive',
+    '.ipa': 'application/octet-stream',
+    '.dmg': 'application/x-apple-diskimage',
+    '.iso': 'application/x-iso9660-image',
+};
+/**
+ * 获取文件的 MIME 类型
+ */
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_TYPES[ext] || '';
+}
+/**
+ * 类型守卫：判断是否为 ClipboardFileData
+ */
+function isClipboardFileData(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        'name' in value &&
+        'path' in value);
+}
+/**
+ * ArrayBuffer 转 Buffer
+ */
+function arrayBufferToBuffer(arrayBuffer) {
+    return Buffer.from(new Uint8Array(arrayBuffer));
+}
+/**
+ * Buffer 转 ArrayBuffer
+ */
+function bufferToArrayBuffer(buffer) {
+    return new Uint8Array(buffer).buffer;
+}
+/**
+ * 获取临时目录路径（缓存）
+ */
+let cachedTempDir = null;
+function getTempDir() {
+    if (!cachedTempDir) {
+        cachedTempDir = electron.app.getPath('temp');
+    }
+    return cachedTempDir;
+}
+/**
+ * 安全读取剪贴板操作（统一错误处理）
+ */
+function safeClipboardOperation(operation, defaultValue, errorMessage) {
+    try {
+        return operation();
+    }
+    catch (error) {
+        console.error(errorMessage, error);
+        return defaultValue;
+    }
+}
+/**
+ * 解析文件 URI 为本地路径
+ */
+function parseFileUri(uri) {
+    const cleanUri = uri.trim();
+    if (cleanUri.startsWith(FILE_URI_PREFIX)) {
+        try {
+            return decodeURIComponent(cleanUri.substring(FILE_URI_PREFIX.length));
+        }
+        catch (error) {
+            console.error('URI 解码失败:', error);
+            return cleanUri.substring(FILE_URI_PREFIX.length);
+        }
+    }
+    try {
+        return decodeURIComponent(cleanUri);
+    }
+    catch (error) {
+        console.error('URI 解码失败:', error);
+        return cleanUri;
+    }
+}
+/**
+ * 规范化文件路径（移除 file:// 前缀，处理相对路径等）
+ */
+function normalizeFilePath(filePath) {
+    const normalized = parseFileUri(filePath);
+    return path.isAbsolute(normalized) ? normalized : path.resolve(normalized);
+}
+/**
+ * 判断字符串是否为 URL（更严格的判断）
+ */
+function isUrl(str) {
+    if (!str || typeof str !== 'string') {
+        return false;
+    }
+    const trimmed = str.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    try {
+        const url = new URL(trimmed);
+        // 必须是 http 或 https 协议
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+        // 必须有 hostname
+        if (!url.hostname || url.hostname.length === 0) {
+            return false;
+        }
+        // 避免将本地文件路径误判为 URL（如 C:\path\to\file）
+        if (url.hostname.includes('\\') || url.hostname.includes(':')) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查剪贴板是否有图片格式
+ */
+function hasImageFormat() {
+    try {
+        const formats = electron.clipboard.availableFormats();
+        // 检查是否有图片格式
+        for (const format of formats) {
+            if (!format)
+                continue;
+            const lowerFormat = format.toLowerCase();
+            // 检查是否匹配图片格式
+            if (IMAGE_FORMATS.some(imgFormat => lowerFormat.includes(imgFormat.toLowerCase()))) {
+                return true;
+            }
+            // 检查常见的图片格式标识
+            if (lowerFormat.startsWith('image/')) {
+                return true;
+            }
+        }
+        // Electron 的 readImage 可能在没有明确格式时也能读取
+        // 尝试读取一次来验证（但不实际读取数据，只检查是否为空）
+        try {
+            const image = electron.clipboard.readImage();
+            if (!image.isEmpty()) {
+                return true;
+            }
+        }
+        catch {
+            // 读取失败，说明不是图片
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查剪贴板是否有文件格式
+ */
+function hasFileFormat() {
+    try {
+        const formats = electron.clipboard.availableFormats();
+        if (PLATFORM === 'win32') {
+            // Windows: 检查 FileNameW 格式
+            return formats.includes(WINDOWS_FILE_FORMAT);
+        }
+        else {
+            // macOS/Linux: 检查文件 URI 格式
+            for (const format of UNIX_FILE_FORMATS) {
+                if (formats.includes(format)) {
+                    return true;
+                }
+            }
+            // 也检查文本中是否包含 file:// URI
+            try {
+                const text = electron.clipboard.readText();
+                if (text && text.includes(FILE_URI_PREFIX)) {
+                    // 进一步验证：检查是否真的是文件路径
+                    const lines = text.split('\n').filter(Boolean);
+                    for (const line of lines) {
+                        if (line.trim().startsWith(FILE_URI_PREFIX)) {
+                            const filePath = parseFileUri(line.trim());
+                            const normalizedPath = normalizeFilePath(filePath);
+                            if (fs.existsSync(normalizedPath)) {
+                                const stat = fs.statSync(normalizedPath);
+                                if (stat.isFile()) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // 忽略错误
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查剪贴板内容是否为 URL（基于格式判断，不读取内容）
+ */
+function hasUrlFormat() {
+    try {
+        const formats = electron.clipboard.availableFormats();
+        // 检查是否有 URL 相关的格式
+        if (formats.includes('text/uri-list') || formats.includes('text/x-moz-url')) {
+            return true;
+        }
+        // 注意：这里不读取文本内容来判断，因为读取会消耗剪贴板
+        // URL 检测将在 handleGetUrl 中进行
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 从 URL 下载文件到本地
+ */
+async function downloadFileFromUrl(url, outputPath) {
+    return new Promise((resolve, reject) => {
+        const lib = url.startsWith('https') ? https : http;
+        const file = fs.createWriteStream(outputPath);
+        let request;
+        const cleanup = () => {
+            if (file) {
+                file.close();
+                if (fs.existsSync(outputPath)) {
+                    fs.unlinkSync(outputPath);
+                }
+            }
+            if (request) {
+                request.destroy();
+            }
+        };
+        request = lib.get(url, (res) => {
+            if (res.statusCode && res.statusCode !== 200) {
+                res.resume(); // 消费响应数据以释放内存
+                cleanup();
+                reject(new Error(`下载失败，状态码: ${res.statusCode} for ${url}`));
+                return;
+            }
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close((err) => {
+                    if (err) {
+                        cleanup();
+                        reject(new Error(`关闭文件流失败: ${err.message}`));
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            file.on('error', (err) => {
+                cleanup();
+                reject(new Error(`写入文件失败: ${err.message}`));
+            });
+        });
+        request.on('error', (err) => {
+            cleanup();
+            reject(new Error(`下载请求失败: ${err.message}`));
+        });
+        request.setTimeout(DOWNLOAD_TIMEOUT, () => {
+            cleanup();
+            reject(new Error('下载超时'));
+        });
+    });
+}
+/**
+ * 从 Windows 剪贴板读取文件路径
+ */
+function readWindowsClipboardFiles() {
+    try {
+        const buffer = electron.clipboard.readBuffer('FileNameW');
+        if (buffer.length === 0) {
+            return [];
+        }
+        // Windows 使用 UCS-2 编码，以 \u0000 分隔多个文件路径
+        const content = buffer.toString('ucs2');
+        return content.split('\u0000').filter(Boolean).map(normalizeFilePath);
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * 从 macOS/Linux 剪贴板读取文件路径
+ */
+function readUnixClipboardFiles() {
+    const filePaths = [];
+    // 方法1: 尝试从文本中解析 file:// URI
+    try {
+        const text = electron.clipboard.readText();
+        if (text && text.includes(FILE_URI_PREFIX)) {
+            const uris = text.split('\n').filter(Boolean);
+            filePaths.push(...uris.map(parseFileUri).map(normalizeFilePath));
+            if (filePaths.length > 0) {
+                return filePaths;
+            }
+        }
+    }
+    catch (error) {
+        // 继续尝试其他方法
+    }
+    // 方法2: 尝试从剪贴板格式列表中读取文件格式
+    try {
+        const formats = electron.clipboard.availableFormats();
+        for (const format of UNIX_FILE_FORMATS) {
+            if (formats.includes(format)) {
+                try {
+                    const buffer = electron.clipboard.readBuffer(format);
+                    if (buffer.length > 0) {
+                        const text = buffer.toString('utf8');
+                        const uris = text.split('\n').filter(Boolean);
+                        filePaths.push(...uris.map(parseFileUri).map(normalizeFilePath));
+                        if (filePaths.length > 0) {
+                            return filePaths;
+                        }
+                    }
+                }
+                catch (error) {
+                    // 继续尝试下一个格式
+                }
+            }
+        }
+    }
+    catch (error) {
+        // 忽略错误
+    }
+    return filePaths;
+}
+/**
+ * 从系统剪贴板读取文件路径
+ * 支持 Windows (FileNameW) 和 macOS/Linux (text/uri-list)
+ */
+function readClipboardFiles() {
+    try {
+        if (PLATFORM === 'win32') {
+            return readWindowsClipboardFiles();
+        }
+        else {
+            return readUnixClipboardFiles();
+        }
+    }
+    catch (error) {
+        console.error('读取剪贴板文件失败:', error);
+        return [];
+    }
+}
+/**
+ * 将文件路径转换为 URI 格式
+ */
+function filePathToUri(filePath) {
+    return filePath.startsWith(FILE_URI_PREFIX) ? filePath : `${FILE_URI_PREFIX}${filePath}`;
+}
+/**
+ * 将文件路径写入 Windows 剪贴板
+ */
+function writeWindowsClipboardFiles(filePaths) {
+    try {
+        // Windows 使用 UCS-2 编码，多个文件路径用 \u0000 分隔，最后以 \u0000\u0000 结尾
+        const content = filePaths.join('\u0000') + '\u0000\u0000';
+        electron.clipboard.writeBuffer('FileNameW', Buffer.from(content, 'ucs2'));
+    }
+    catch (error) {
+        console.error('写入文件到 Windows 剪贴板失败:', error);
+        throw error;
+    }
+}
+/**
+ * 将文件路径写入 macOS/Linux 剪贴板
+ */
+function writeUnixClipboardFiles(filePaths) {
+    try {
+        // macOS/Linux 使用 URI 列表格式
+        const uriList = filePaths.map(filePathToUri).join('\n');
+        electron.clipboard.writeText(uriList);
+        // 注意：macOS 的文件剪贴板需要使用原生 API (NSFilenamesPboardType)
+        // 当前实现可能无法让系统完全识别为文件，需要进一步优化
+    }
+    catch (error) {
+        console.error('写入文件到 Unix 剪贴板失败:', error);
+        throw error;
+    }
+}
+/**
+ * 将文件路径写入系统剪贴板
+ * 支持 Windows (FileNameW) 和 macOS/Linux (text/uri-list)
+ */
+function writeClipboardFiles(filePaths) {
+    if (filePaths.length === 0) {
+        return false;
+    }
+    try {
+        if (PLATFORM === 'win32') {
+            writeWindowsClipboardFiles(filePaths);
+        }
+        else {
+            writeUnixClipboardFiles(filePaths);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('写入文件到剪贴板失败:', error);
+        return false;
+    }
+}
+/**
+ * 读取文件信息并返回 File 对象需要的数据
+ */
+function readFileData(filePath, options = {}) {
+    const { includeBuffer = true, maxFileSize = MAX_FILE_SIZE } = options;
+    try {
+        const normalizedPath = normalizeFilePath(filePath);
+        if (!fs.existsSync(normalizedPath)) {
+            console.warn('文件不存在:', normalizedPath);
+            return null;
+        }
+        const stat = fs.statSync(normalizedPath);
+        // 检查是否为文件（不是目录）
+        if (!stat.isFile()) {
+            console.warn('路径不是文件:', normalizedPath);
+            return null;
+        }
+        const fileData = {
+            name: path.basename(normalizedPath),
+            path: normalizedPath,
+            size: stat.size,
+            type: getMimeType(normalizedPath),
+            lastModified: stat.mtimeMs,
+        };
+        // 根据选项决定是否读取文件内容
+        if (includeBuffer && stat.size <= maxFileSize) {
+            try {
+                const buffer = fs.readFileSync(normalizedPath);
+                fileData.buffer = bufferToArrayBuffer(buffer);
+            }
+            catch (error) {
+                console.error('读取文件内容失败:', error);
+                // 即使读取失败，也返回文件基本信息
+            }
+        }
+        return fileData;
+    }
+    catch (error) {
+        console.error('读取文件失败:', error);
+        return null;
+    }
+}
+/**
+ * 从文件名或 URL 中提取文件扩展名
+ */
+function extractExtension(fileNameOrUrl) {
+    try {
+        // 如果是 URL，尝试从 URL 路径中获取扩展名
+        if (isUrl(fileNameOrUrl)) {
+            const url = new URL(fileNameOrUrl);
+            const urlPath = url.pathname;
+            const ext = path.extname(urlPath);
+            if (ext) {
+                return ext;
+            }
+        }
+        // 否则从文件名获取扩展名
+        return path.extname(fileNameOrUrl);
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * 生成临时文件名（保留原始扩展名）
+ */
+function generateTempFileName(originalName, url) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(7);
+    if (originalName) {
+        const ext = path.extname(originalName);
+        const nameWithoutExt = path.basename(originalName, ext) || 'file';
+        return `${nameWithoutExt}_${timestamp}_${random}${ext}`;
+    }
+    if (url) {
+        const ext = extractExtension(url);
+        return `clipboard_${timestamp}_${random}${ext}`;
+    }
+    return `clipboard_${timestamp}_${random}`;
+}
+/**
+ * 将 File 对象保存到临时目录并返回文件路径
+ * 支持本地路径、URL 和 buffer
+ */
+async function saveFileToTemp(fileData) {
+    try {
+        const tempDir = getTempDir();
+        // 如果已经有 buffer，直接保存到临时目录
+        if (fileData.buffer) {
+            const fileName = generateTempFileName(fileData.name, fileData.path);
+            const tempPath = path.join(tempDir, fileName);
+            const buffer = arrayBufferToBuffer(fileData.buffer);
+            fs.writeFileSync(tempPath, buffer);
+            return tempPath;
+        }
+        // 如果 path 是 URL，需要先下载
+        if (fileData.path && isUrl(fileData.path)) {
+            const fileName = generateTempFileName(fileData.name, fileData.path);
+            const tempPath = path.join(tempDir, fileName);
+            try {
+                await downloadFileFromUrl(fileData.path, tempPath);
+                return tempPath;
+            }
+            catch (error) {
+                console.error('从 URL 下载文件失败:', error);
+                return null;
+            }
+        }
+        // 如果 path 是本地路径，检查文件是否存在
+        if (fileData.path) {
+            const normalizedPath = normalizeFilePath(fileData.path);
+            if (fs.existsSync(normalizedPath)) {
+                const stat = fs.statSync(normalizedPath);
+                if (stat.isFile()) {
+                    return normalizedPath;
+                }
+                // 如果是目录，返回 null（目录不能复制到剪贴板）
+                console.warn('路径是目录，不是文件:', normalizedPath);
+                return null;
+            }
+            // 文件不存在
+            console.warn('文件不存在:', normalizedPath);
+            return null;
+        }
+        // 既没有 buffer 也没有有效路径
+        return null;
+    }
+    catch (error) {
+        console.error('保存文件到临时目录失败:', error);
+        return null;
+    }
+}
+/**
+ * 读取文本类型
+ */
+function handleGetText() {
+    return safeClipboardOperation(() => electron.clipboard.readText(), '', '读取文本失败:');
+}
+/**
+ * 读取 HTML 类型
+ */
+function handleGetHtml() {
+    return safeClipboardOperation(() => {
+        const html = electron.clipboard.readHTML();
+        return { type: 'html', html: html || '' };
+    }, { type: 'html', html: '' }, '读取 HTML 失败:');
+}
+/**
+ * 从剪贴板图片创建文件数据（可重用逻辑）
+ */
+function createImageFileDataFromClipboard(options) {
+    try {
+        const image = electron.clipboard.readImage();
+        if (image.isEmpty()) {
+            return null;
+        }
+        const pngBuffer = image.toPNG();
+        const arrayBuffer = bufferToArrayBuffer(pngBuffer);
+        const tempDir = getTempDir();
+        const fileName = `clipboard_image_${Date.now()}.png`;
+        const tempPath = path.join(tempDir, fileName);
+        fs.writeFileSync(tempPath, pngBuffer);
+        const fileData = {
+            name: fileName,
+            path: tempPath,
+            size: pngBuffer.length,
+            type: 'image/png',
+            lastModified: Date.now(),
+        };
+        // 如果选项允许，包含 buffer
+        const maxSize = options?.maxFileSize || MAX_FILE_SIZE;
+        if (options?.includeBuffer !== false && arrayBuffer.byteLength <= maxSize) {
+            fileData.buffer = arrayBuffer;
+        }
+        return fileData;
+    }
+    catch (error) {
+        console.error('创建图片文件数据失败:', error);
+        return null;
+    }
+}
+/**
+ * 读取图片类型
+ */
+function handleGetImage(options) {
+    // 先检查是否有图片格式，避免误判
+    if (!hasImageFormat()) {
+        // 即使没有明确的图片格式，也尝试读取（Electron 可能能读取）
+        // 但如果读取失败，返回空结果
+        const imageData = createImageFileDataFromClipboard(options);
+        if (imageData) {
+            return { type: 'image', image: imageData };
+        }
+        return { type: 'image' };
+    }
+    // 有图片格式，尝试读取
+    const imageData = createImageFileDataFromClipboard(options);
+    if (imageData) {
+        return { type: 'image', image: imageData };
+    }
+    return { type: 'image' };
+}
+/**
+ * 读取 URL 类型
+ */
+function handleGetUrl() {
+    try {
+        // 先检查是否有 URL 格式
+        if (!hasUrlFormat()) {
+            return { type: 'url' };
+        }
+        // 检查是否有 URL 相关的格式
+        const formats = electron.clipboard.availableFormats();
+        // 优先检查 text/uri-list 或 text/x-moz-url 格式
+        if (formats.includes('text/uri-list') || formats.includes('text/x-moz-url')) {
+            try {
+                const uriList = electron.clipboard.readText();
+                if (uriList) {
+                    const uris = uriList.split('\n').filter(Boolean);
+                    // 查找第一个有效的 HTTP/HTTPS URL
+                    for (const uri of uris) {
+                        const trimmed = uri.trim();
+                        if (isUrl(trimmed)) {
+                            return { type: 'url', url: trimmed };
+                        }
+                    }
+                }
+            }
+            catch {
+                // 忽略错误，继续尝试其他方法
+            }
+        }
+        // 尝试从普通文本中读取 URL
+        try {
+            const text = electron.clipboard.readText();
+            if (text) {
+                const trimmed = text.trim();
+                // 检查整段文本是否为 URL
+                if (isUrl(trimmed)) {
+                    return { type: 'url', url: trimmed };
+                }
+                // 尝试从文本中提取 URL（简单模式：查找 http:// 或 https://）
+                const urlMatch = trimmed.match(/https?:\/\/[^\s]+/);
+                if (urlMatch && urlMatch[0] && isUrl(urlMatch[0])) {
+                    return { type: 'url', url: urlMatch[0] };
+                }
+            }
+        }
+        catch {
+            // 忽略错误
+        }
+        return { type: 'url' };
+    }
+    catch (error) {
+        console.error('读取 URL 失败:', error);
+        return { type: 'url' };
+    }
+}
+/**
+ * 读取 Buffer 类型
+ */
+function handleGetBuffer() {
+    return safeClipboardOperation(() => {
+        const formats = electron.clipboard.availableFormats();
+        if (formats.length === 0 || !formats[0]) {
+            return { type: 'buffer' };
+        }
+        const buffer = electron.clipboard.readBuffer(formats[0]);
+        if (buffer.length > 0) {
+            const arrayBuffer = bufferToArrayBuffer(buffer);
+            return { type: 'buffer', buffer: arrayBuffer };
+        }
+        return { type: 'buffer' };
+    }, { type: 'buffer' }, '读取 Buffer 失败:');
+}
+/**
+ * 读取文件类型（单个）
+ */
+function handleGetFile(options) {
+    // 先检查是否有文件格式，避免误判
+    if (!hasFileFormat()) {
+        return { type: 'file' };
+    }
+    const filePaths = readClipboardFiles();
+    if (filePaths.length === 0 || !filePaths[0]) {
+        return { type: 'file' };
+    }
+    const fileData = readFileData(filePaths[0], options);
+    if (!fileData) {
+        return { type: 'file' };
+    }
+    return { type: 'file', file: fileData };
+}
+/**
+ * 自动检测类型（基于格式检测，优先文件，然后是图片、URL，最后是文本）
+ */
+function handleGetAuto(options) {
+    // 先获取剪贴板格式，避免重复调用
+    let formats = [];
+    try {
+        formats = electron.clipboard.availableFormats();
+    }
+    catch {
+        // 如果获取格式失败，降级到文本
+        const text = handleGetText();
+        return { type: 'text', text: text || '' };
+    }
+    // 1. 优先检测文件（基于格式检测）
+    if (hasFileFormat()) {
+        const filePaths = readClipboardFiles();
+        if (filePaths.length > 0) {
+            if (filePaths.length === 1) {
+                const firstPath = filePaths[0];
+                if (firstPath) {
+                    const fileData = readFileData(firstPath, options);
+                    if (fileData) {
+                        return { type: 'file', file: fileData };
+                    }
+                }
+            }
+            else {
+                // 多个文件
+                const files = filePaths
+                    .map(filePath => readFileData(filePath, options))
+                    .filter((file) => file !== null);
+                if (files.length > 0) {
+                    return { type: 'files', files };
+                }
+            }
+        }
+    }
+    // 2. 检测图片（基于格式检测）
+    if (hasImageFormat()) {
+        const imageData = createImageFileDataFromClipboard(options);
+        if (imageData) {
+            return { type: 'image', image: imageData };
+        }
+    }
+    // 3. 检测 URL（基于格式检测，或文本内容判断）
+    // 优先检查是否有 URL 格式
+    if (hasUrlFormat()) {
+        const urlResult = handleGetUrl();
+        if (urlResult.url) {
+            return urlResult;
+        }
+    }
+    // 4. 检测 HTML（检查格式）
+    if (formats.includes('text/html') || formats.some(f => f && f.toLowerCase().includes('html'))) {
+        const htmlData = safeClipboardOperation(() => electron.clipboard.readHTML(), '', '读取 HTML 失败:');
+        if (htmlData && htmlData.trim().length > 0) {
+            return { type: 'html', html: htmlData };
+        }
+    }
+    // 5. 最后读取文本，并检查是否为 URL
+    const text = safeClipboardOperation(() => electron.clipboard.readText(), '', '读取文本失败:');
+    if (text && text.trim().length > 0) {
+        const trimmed = text.trim();
+        // 如果文本是纯 URL（单行且是有效的 URL），且之前没有检测到 URL 格式
+        // 则判断为 URL 类型
+        if (!trimmed.includes('\n') && isUrl(trimmed)) {
+            return { type: 'url', url: trimmed };
+        }
+        // 否则返回文本类型
+        return { type: 'text', text: trimmed };
+    }
+    return { type: 'text', text: '' };
+}
+/**
+ * 判断字符串是否为文件路径或 URL
+ */
+function isFilePathOrUrl(str) {
+    // 检查是否为 URL (http/https)
+    if (isUrl(str)) {
+        return true;
+    }
+    // 检查是否为 file:// URI
+    if (str.startsWith(FILE_URI_PREFIX)) {
+        return true;
+    }
+    // 检查是否为本地文件路径（绝对路径或相对路径）
+    try {
+        const normalizedPath = normalizeFilePath(str);
+        if (fs.existsSync(normalizedPath)) {
+            const stat = fs.statSync(normalizedPath);
+            return stat.isFile();
+        }
+    }
+    catch {
+        // 忽略错误
+    }
+    return false;
+}
+/**
+ * 处理字符串路径/URL：下载到临时文件后写入剪贴板
+ */
+async function handleSetStringAsFile(input) {
+    try {
+        let tempPath = null;
+        // 如果是 http/https URL，下载到临时文件
+        if (isUrl(input)) {
+            const tempDir = electron.app.getPath('temp');
+            const fileName = generateTempFileName(undefined, input);
+            tempPath = path.join(tempDir, fileName);
+            try {
+                await downloadFileFromUrl(input, tempPath);
+            }
+            catch (error) {
+                console.error('从 URL 下载文件失败:', error);
+                return false;
+            }
+        }
+        // 如果是 file:// URI 或本地路径
+        else {
+            console.log('error input', input);
+            const normalizedPath = normalizeFilePath(input);
+            if (!fs.existsSync(normalizedPath)) {
+                console.warn('文件不存在:', normalizedPath);
+                return false;
+            }
+            const stat = fs.statSync(normalizedPath);
+            if (!stat.isFile()) {
+                console.warn('路径不是文件:', normalizedPath);
+                return false;
+            }
+            tempPath = normalizedPath;
+        }
+        if (!tempPath) {
+            return false;
+        }
+        // 将临时文件路径写入剪贴板
+        return writeClipboardFiles([tempPath]);
+    }
+    catch (error) {
+        console.error('处理文件路径/URL 失败:', error);
+        return false;
+    }
+}
+/**
+ * 写入文本
+ */
+function handleSetText(text) {
+    return safeClipboardOperation(() => {
+        electron.clipboard.writeText(text);
+        return true;
+    }, false, '写入文本到剪贴板失败:');
+}
+/**
+ * 写入 HTML
+ */
+function handleSetHtml(html) {
+    return safeClipboardOperation(() => {
+        electron.clipboard.writeHTML(html);
+        return true;
+    }, false, '写入 HTML 到剪贴板失败:');
+}
+/**
+ * 写入图片
+ */
+async function handleSetImage(imageData) {
+    try {
+        let image;
+        if (typeof imageData === 'string') {
+            // 检查是否是 HTTP/HTTPS URL
+            if (imageData.startsWith('http://') || imageData.startsWith('https://')) {
+                // 下载图片到临时文件
+                const tempDir = getTempDir();
+                const fileName = generateTempFileName(undefined, imageData);
+                const tempPath = path.join(tempDir, fileName);
+                await downloadFileFromUrl(imageData, tempPath);
+                // 检查下载后的文件是否存在
+                if (!fs.existsSync(tempPath)) {
+                    console.error('下载的图片文件不存在:', tempPath);
+                    return false;
+                }
+                image = electron.nativeImage.createFromPath(tempPath);
+            }
+            else if (imageData.startsWith('file://')) {
+                // 处理 file:// 协议，去掉前缀
+                const localPath = imageData.replace(/^file:\/\//, '');
+                // 检查文件是否存在
+                if (!fs.existsSync(localPath)) {
+                    console.error('图片文件不存在:', localPath);
+                    return false;
+                }
+                image = electron.nativeImage.createFromPath(localPath);
+            }
+            else if (imageData.startsWith('/')) {
+                // 本地路径，直接使用
+                // 检查文件是否存在
+                if (!fs.existsSync(imageData)) {
+                    console.error('图片文件不存在:', imageData);
+                    return false;
+                }
+                image = electron.nativeImage.createFromPath(imageData);
+            }
+            else {
+                // 其他情况，尝试直接使用
+                // 检查文件是否存在
+                if (!fs.existsSync(imageData)) {
+                    console.error('图片文件不存在:', imageData);
+                    return false;
+                }
+                image = electron.nativeImage.createFromPath(imageData);
+            }
+        }
+        else if (imageData instanceof ArrayBuffer) {
+            const buffer = arrayBufferToBuffer(imageData);
+            image = electron.nativeImage.createFromBuffer(buffer);
+        }
+        else {
+            // 如果传入的是 ClipboardFileData
+            const savedPath = await saveFileToTemp(imageData);
+            if (!savedPath) {
+                return false;
+            }
+            image = electron.nativeImage.createFromPath(savedPath);
+        }
+        if (!image.isEmpty()) {
+            electron.clipboard.writeImage(image);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        console.error('写入图片到剪贴板失败:', error);
+        return false;
+    }
+}
+/**
+ * 写入 Buffer
+ */
+function handleSetBuffer(buffer) {
+    return safeClipboardOperation(() => {
+        const nodeBuffer = arrayBufferToBuffer(buffer);
+        // Electron 的 clipboard.writeBuffer 需要指定格式
+        // 使用 'application/octet-stream' 作为默认格式
+        electron.clipboard.writeBuffer('application/octet-stream', nodeBuffer);
+        return true;
+    }, false, '写入 Buffer 到剪贴板失败:');
+}
+/**
+ * 清空剪贴板
+ */
+function handleClear() {
+    return safeClipboardOperation(() => {
+        electron.clipboard.clear();
+        return true;
+    }, false, '清空剪贴板失败:');
+}
+/**
+ * 写入单个文件
+ */
+async function handleSetFile(fileData) {
+    const savedPath = await saveFileToTemp(fileData);
+    if (!savedPath) {
+        return false;
+    }
+    return writeClipboardFiles([savedPath]);
+}
+/**
+ * 写入多个文件
+ */
+async function handleSetFiles(files) {
+    if (files.length === 0) {
+        return false;
+    }
+    const filePaths = [];
+    for (const fileData of files) {
+        const savedPath = await saveFileToTemp(fileData);
+        if (savedPath) {
+            filePaths.push(savedPath);
+        }
+    }
+    if (filePaths.length === 0) {
+        return false;
+    }
+    return writeClipboardFiles(filePaths);
+}
+/**
+ * 初始化剪贴板 IPC 处理器
+ */
+const initializeClipboard = () => {
+    ipc.mainIPC.handleRenderer('core:clipboard', async (options) => {
+        const { method, value, type = 'auto', options: fileOptions } = options;
+        try {
+            if (method === 'get') {
+                // 从系统剪贴板读取内容
+                switch (type) {
+                    case 'text':
+                        return handleGetText();
+                    case 'html':
+                        return handleGetHtml();
+                    case 'image':
+                        return handleGetImage();
+                    case 'file':
+                        return handleGetFile(fileOptions);
+                    case 'url':
+                        return handleGetUrl();
+                    case 'buffer':
+                        return handleGetBuffer();
+                    default: {
+                        return handleGetAuto(fileOptions);
+                    }
+                }
+            }
+            if (method === 'set') {
+                // 写入系统剪贴板
+                if (value === undefined || value === null) {
+                    return false;
+                }
+                // 使用更清晰的类型检查和处理
+                switch (type) {
+                    case 'text':
+                        if (typeof value === 'string') {
+                            return handleSetText(value);
+                        }
+                        break;
+                    case 'html':
+                        if (typeof value === 'string') {
+                            return handleSetHtml(value);
+                        }
+                        break;
+                    case 'image':
+                        if (typeof value === 'string') {
+                            return await handleSetImage(value);
+                        }
+                        if (value instanceof ArrayBuffer) {
+                            return await handleSetImage(value);
+                        }
+                        if (isClipboardFileData(value)) {
+                            return await handleSetImage(value);
+                        }
+                        break;
+                    case 'file':
+                        if (isClipboardFileData(value)) {
+                            return await handleSetFile(value);
+                        }
+                        if (Array.isArray(value) && value.every(isClipboardFileData)) {
+                            return await handleSetFiles(value);
+                        }
+                        break;
+                    case 'url':
+                        if (typeof value === 'string' && isFilePathOrUrl(value)) {
+                            return await handleSetStringAsFile(value);
+                        }
+                        break;
+                    case 'buffer':
+                        if (value instanceof ArrayBuffer) {
+                            return handleSetBuffer(value);
+                        }
+                        break;
+                }
+            }
+            if (method === 'clear') {
+                return handleClear();
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('剪贴板操作失败:', error);
+            return false;
+        }
+    });
+};
+
+exports.initializeClipboard = initializeClipboard;
+//# sourceMappingURL=clipboard.js.map