markpdfdown 0.1.8-beta.6 → 0.2.0

package/dist/server/db/migration.js

@@ -1,157 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import isDev from 'electron-is-dev';
-import { app } from 'electron';
-// 获取迁移文件目录
-const getMigrationsDir = () => {
-    // 在开发环境使用项目目录
-    if (isDev) {
-        return path.join(process.cwd(), 'src', 'server', 'db', 'migrations');
-    }
-    // 在打包环境中，确保使用正确的路径
-    // 使用app.getAppPath()获取应用根目录
-    if (app) {
-        return path.join(app.getAppPath(), '..', 'migrations');
-    }
-    // 回退到__dirname相对路径
-    return path.join(__dirname, 'migrations');
-};
-// 创建 _prisma_migrations 表的SQL
-const createMigrationsTableSQL = `
-CREATE TABLE IF NOT EXISTS _prisma_migrations (
-  id                    VARCHAR(36) PRIMARY KEY NOT NULL,
-  checksum              VARCHAR(64) NOT NULL,
-  finished_at           DATETIME,
-  migration_name        VARCHAR(255) NOT NULL,
-  logs                  TEXT,
-  rolled_back_at        DATETIME,
-  started_at            DATETIME NOT NULL DEFAULT current_timestamp,
-  applied_steps_count   INTEGER UNSIGNED NOT NULL DEFAULT 0
-);
-`;
-// 检查迁移是否已应用
-const isMigrationApplied = async (prisma, migrationName) => {
-    try {
-        // 检查 _prisma_migrations 表是否存在
-        const tableExists = await prisma.$queryRaw `
-      SELECT name FROM sqlite_master 
-      WHERE type='table' AND name='_prisma_migrations';
-    `;
-        if (!tableExists || tableExists.length === 0) {
-            return false;
-        }
-        // 检查特定迁移是否已应用
-        const migration = await prisma.$queryRaw `
-      SELECT * FROM _prisma_migrations 
-      WHERE migration_name = ${migrationName} 
-      AND finished_at IS NOT NULL;
-    `;
-        return migration && migration.length > 0;
-    }
-    catch (error) {
-        console.error('Error checking migration status:', error);
-        return false;
-    }
-};
-// 记录已应用的迁移
-const recordMigration = async (prisma, migrationName, checksum) => {
-    const id = generateUUID();
-    const now = new Date().toISOString();
-    try {
-        await prisma.$executeRaw `
-      INSERT INTO _prisma_migrations (
-        id, checksum, migration_name, started_at, finished_at, applied_steps_count
-      ) VALUES (
-        ${id}, ${checksum}, ${migrationName}, ${now}, ${now}, 1
-      );
-    `;
-        console.log(`Recorded migration: ${migrationName}`);
-    }
-    catch (error) {
-        console.error(`Failed to record migration ${migrationName}:`, error);
-    }
-};
-// 生成UUID
-const generateUUID = () => {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-};
-// 计算迁移文件的checksum
-const calculateChecksum = async (content) => {
-    // 使用ESM方式导入crypto
-    const crypto = await import('crypto');
-    return crypto.default.createHash('sha256').update(content).digest('hex');
-};
-// 应用单个迁移
-const applyMigration = async (prisma, migrationDir, migrationName) => {
-    const sqlFilePath = path.join(migrationDir, migrationName, 'migration.sql');
-    try {
-        if (!fs.existsSync(sqlFilePath)) {
-            console.error(`Migration SQL file not found: ${sqlFilePath}`);
-            return false;
-        }
-        const sqlContent = fs.readFileSync(sqlFilePath, 'utf8');
-        const sqlStatements = sqlContent.split(';').filter(stmt => stmt.trim());
-        // 应用每条SQL语句
-        for (const statement of sqlStatements) {
-            if (statement.trim()) {
-                await prisma.$executeRawUnsafe(statement.trim());
-            }
-        }
-        // 记录迁移
-        const checksum = await calculateChecksum(sqlContent);
-        await recordMigration(prisma, migrationName, checksum);
-        console.log(`Successfully applied migration: ${migrationName}`);
-        return true;
-    }
-    catch (error) {
-        console.error(`Failed to apply migration ${migrationName}:`, error);
-        return false;
-    }
-};
-// 主要的迁移函数
-const runMigrations = async (prisma = null) => {
-    console.log('Running database migrations...');
-    try {
-        // 确保_prisma_migrations表存在
-        await prisma.$executeRawUnsafe(createMigrationsTableSQL);
-        const migrationsDir = getMigrationsDir();
-        console.log('Migrations directory:', migrationsDir);
-        if (!fs.existsSync(migrationsDir)) {
-            console.error(`Migrations directory not found: ${migrationsDir}`);
-            return false;
-        }
-        // 读取所有迁移目录并按名称排序
-        const migrationDirs = fs
-            .readdirSync(migrationsDir)
-            .filter(dir => {
-            const stat = fs.statSync(path.join(migrationsDir, dir));
-            return stat.isDirectory() && dir !== 'migration_lock.toml';
-        })
-            .sort(); // 按名称排序，确保按正确顺序应用
-        let migrationsApplied = 0;
-        // 应用每个迁移
-        for (const migrationName of migrationDirs) {
-            const isApplied = await isMigrationApplied(prisma, migrationName);
-            if (!isApplied) {
-                console.log(`Applying migration: ${migrationName}`);
-                const success = await applyMigration(prisma, migrationsDir, migrationName);
-                if (success)
-                    migrationsApplied++;
-            }
-            else {
-                console.log(`Migration already applied: ${migrationName}`);
-            }
-        }
-        console.log(`Database migration complete. Applied ${migrationsApplied} migrations.`);
-        return migrationsApplied > 0;
-    }
-    catch (error) {
-        console.error('Migration error:', error);
-        return false;
-    }
-};
-export { runMigrations };

package/dist/server/index.js

@@ -1,49 +0,0 @@
-import express from 'express';
-import cors from 'cors';
-import bodyParser from 'body-parser';
-import { requestLogger, errorLogger } from './middleware/Logger.js';
-import { initDatabase, disconnect } from './db/index.js';
-// 初始化Express应用
-const app = express();
-// 中间件配置
-app.use(cors());
-app.use(bodyParser.json());
-app.use(bodyParser.urlencoded({ extended: true }));
-app.use(requestLogger);
-// 导入路由
-import routes from './routes/Routes.js';
-// 使用路由
-app.use('/api', routes);
-// 健康检查
-app.get('/health', (_req, res) => {
-    res.status(200).json({ status: 'ok' });
-});
-// 错误日志中间件
-app.use(errorLogger);
-// 错误处理中间件
-app.use((err, _req, res, _next) => {
-    res.status(500).json({
-        message: 'Internal Server Error',
-        error: process.env.NODE_ENV === 'development' ? err.message : undefined
-    });
-});
-// 优雅关闭
-process.on('SIGINT', async () => {
-    await disconnect();
-    console.log('Backend server has been shut down');
-    process.exit(0);
-});
-let server = null;
-export { app };
-export const start = async () => {
-    // 确保不会重复启动服务器
-    if (server) {
-        return server;
-    }
-    // 在启动服务器前初始化数据库
-    await initDatabase();
-    // 启动服务器并监听随机端口
-    server = app.listen(0, 'localhost');
-    return server;
-};
-export const getServer = () => server;

package/dist/server/logic/File.js

@@ -1,34 +0,0 @@
-import { app } from "electron";
-import isDev from "electron-is-dev";
-import path from "path";
-import fs from "fs";
-// 获取上传目录
-const getUploadDir = () => {
-    // DEV目录
-    if (isDev) {
-        return path.join(process.cwd(), 'files');
-    }
-    // 打包目录
-    const userDataPath = app.getPath('userData');
-    return path.join(userDataPath, 'files');
-};
-// 删除任务对应的文件
-const deleteTaskFiles = (id) => {
-    const baseUploadDir = getUploadDir();
-    const uploadDir = path.join(baseUploadDir, id);
-    // 检查路径是否存在
-    if (fs.existsSync(uploadDir)) {
-        // 如果是目录，使用递归删除
-        if (fs.lstatSync(uploadDir).isDirectory()) {
-            fs.rmSync(uploadDir, { recursive: true, force: true });
-        }
-        else {
-            // 如果是文件，使用unlinkSync
-            fs.unlinkSync(uploadDir);
-        }
-    }
-};
-export default {
-    getUploadDir,
-    deleteTaskFiles,
-};

package/dist/server/logic/Task.js

@@ -1,21 +0,0 @@
-class TaskLogic {
-    constructor() {
-        this.isRunning = false;
-    }
-    async start() {
-        this.isRunning = true;
-        while (this.isRunning) {
-            console.log('Task is running');
-            await new Promise(resolve => setTimeout(resolve, 1000));
-        }
-    }
-    async stop() {
-        this.isRunning = false;
-        console.log('Task stopped');
-    }
-    // 获取状态
-    getStatus() {
-        return this.isRunning;
-    }
-}
-export default new TaskLogic();

package/dist/server/logic/llm/AnthropicClient.js

@@ -1,220 +0,0 @@
-import { LLMClient } from './LLMClient.js';
-/**
- * Anthropic客户端实现
- */
-export class AnthropicClient extends LLMClient {
-    constructor(apiKey, baseUrl, apiVersion = '2023-06-01') {
-        super(apiKey, baseUrl || 'https://api.anthropic.com/v1/messages');
-        this.apiVersion = apiVersion;
-    }
-    /**
-     * 执行Anthropic文本补全
-     */
-    async completion(options) {
-        try {
-            // 标准化选项，处理向后兼容
-            const normalizedOptions = this.normalizeOptions(options);
-            const endpoint = `${this.baseUrl}`;
-            const modelName = normalizedOptions.model || 'claude-3-opus-20240229';
-            // 将消息转换为Anthropic格式
-            const anthropicMessages = this.convertMessagesToAnthropicFormat(normalizedOptions.messages);
-            const requestBody = {
-                model: modelName,
-                messages: anthropicMessages,
-                temperature: normalizedOptions.temperature ?? 0.7,
-                max_tokens: normalizedOptions.maxTokens,
-                stream: normalizedOptions.stream || false
-            };
-            // Anthropic支持System指令，而不是作为一个普通消息
-            const systemMessage = normalizedOptions.messages.find(msg => msg.role === 'system');
-            if (systemMessage) {
-                const systemContent = Array.isArray(systemMessage.content)
-                    ? systemMessage.content.filter(c => c.type === 'text').map(c => c.text).join('\n')
-                    : systemMessage.content.type === 'text' ? systemMessage.content.text : '';
-                if (systemContent) {
-                    requestBody.system = systemContent;
-                }
-            }
-            // Claude没有直接的JSON响应格式，但可以通过系统指令引导
-            if (normalizedOptions.response_format?.type === 'json_object' && !requestBody.system) {
-                requestBody.system = "请以有效的JSON格式提供响应。";
-            }
-            else if (normalizedOptions.response_format?.type === 'json_object' && requestBody.system) {
-                requestBody.system += "\n\n请以有效的JSON格式提供响应。";
-            }
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': normalizedOptions.apiKey || this.apiKey,
-                    'anthropic-version': this.apiVersion
-                },
-                body: JSON.stringify(requestBody)
-            });
-            console.log(`[${new Date().toISOString()}] POST ${endpoint} ${response.status} - ${response.statusText}`);
-            if (!response.ok) {
-                const error = await response.json();
-                throw new Error(`Anthropic API错误: ${error.error?.message || response.statusText}`);
-            }
-            if (normalizedOptions.stream && response.body && normalizedOptions.onUpdate) {
-                // 处理流式响应
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                const processStream = async () => {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        return {
-                            content,
-                            model: modelName,
-                            finishReason: 'stop',
-                            responseFormat: normalizedOptions.response_format?.type
-                        };
-                    }
-                    // 解析流式响应数据
-                    const chunk = decoder.decode(value);
-                    const lines = chunk
-                        .split('\n')
-                        .filter(line => line.trim() !== '' && line.trim() !== 'data: [DONE]');
-                    for (const line of lines) {
-                        if (line.startsWith('data: ')) {
-                            try {
-                                const data = JSON.parse(line.slice(6));
-                                // Claude 3使用content_block_delta类型流式传输内容
-                                if (data.type === 'content_block_delta' && data.delta?.text) {
-                                    content += data.delta.text;
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                                // 兼容Claude 2流式响应格式
-                                if (data.completion) {
-                                    const newContent = data.completion;
-                                    content = newContent; // Claude 2返回完整内容，而不是增量
-                                    if (normalizedOptions.onUpdate) {
-                                        normalizedOptions.onUpdate(content);
-                                    }
-                                }
-                            }
-                            catch (e) {
-                                // 忽略解析错误
-                            }
-                        }
-                    }
-                    return processStream();
-                };
-                return processStream();
-            }
-            else {
-                // 处理普通响应
-                const data = await response.json();
-                // Claude API返回格式
-                let content = '';
-                // Claude 3格式
-                if (data.content) {
-                    // 提取所有文本块
-                    for (const block of data.content) {
-                        if (block.type === 'text') {
-                            content += block.text;
-                        }
-                    }
-                }
-                // 兼容Claude 2格式
-                else if (data.completion) {
-                    content = data.completion;
-                }
-                return {
-                    content,
-                    model: data.model,
-                    finishReason: data.stop_reason,
-                    responseFormat: normalizedOptions.response_format?.type,
-                    rawResponse: data // 保留原始响应以便调试
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Anthropic补全请求失败: ${errorMessage}`);
-        }
-    }
-    /**
-     * 将消息转换为Anthropic API格式
-     * Claude API移除系统消息，这将在请求体中单独处理
-     */
-    convertMessagesToAnthropicFormat(messages) {
-        return messages
-            .filter(msg => msg.role !== 'system') // 系统消息会在请求体中单独处理
-            .map(message => {
-            // Anthropic只支持user和assistant角色
-            let role = message.role === 'user' ? 'user' : 'assistant';
-            // 将tool角色视为user角色
-            if (message.role === 'tool') {
-                role = 'user';
-            }
-            const anthropicMessage = {
-                role
-            };
-            // 处理内容
-            if (Array.isArray(message.content)) {
-                anthropicMessage.content = this.convertContentArrayToAnthropicFormat(message.content);
-            }
-            else {
-                anthropicMessage.content = this.convertContentToAnthropicFormat(message.content);
-            }
-            return anthropicMessage;
-        });
-    }
-    /**
-     * 将内容数组转换为Anthropic内容格式
-     */
-    convertContentArrayToAnthropicFormat(contentArray) {
-        return contentArray.map(content => this.convertContentToAnthropicFormat(content)).flat();
-    }
-    /**
-     * 将单个内容转换为Anthropic内容格式
-     */
-    convertContentToAnthropicFormat(content) {
-        switch (content.type) {
-            case 'text':
-                return [{
-                        type: 'text',
-                        text: content.text
-                    }];
-            case 'image_url':
-                const imageContent = content;
-                let source;
-                if (imageContent.image_url.url.startsWith('data:')) {
-                    // 处理Base64数据URI
-                    const parts = imageContent.image_url.url.split(';base64,');
-                    if (parts.length === 2) {
-                        const mediaType = parts[0].replace('data:', '');
-                        source = {
-                            type: 'base64',
-                            media_type: mediaType,
-                            data: parts[1]
-                        };
-                    }
-                }
-                else {
-                    // 处理URL
-                    source = {
-                        type: 'url',
-                        url: imageContent.image_url.url
-                    };
-                }
-                return [{
-                        type: 'image',
-                        source
-                    }];
-            // Anthropic不支持工具调用和工具结果，将其转换为文本
-            case 'tool_call':
-            case 'tool_result':
-                return [{
-                        type: 'text',
-                        text: JSON.stringify(content)
-                    }];
-            default:
-                throw new Error(`Anthropic不支持的内容类型: ${content.type}`);
-        }
-    }
-}