自动更新 #

┌─────────────────────────────────────────────────────────────┐
│                      更新流程                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  应用启动 ──► 检查更新 ──► 下载更新 ──► 安装更新 ──► 重启    │
│      │           │           │           │           │      │
│      ▼           ▼           ▼           ▼           ▼      │
│   启动应用    请求服务器    下载文件    替换文件    完成更新  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

pnpm add @tauri-apps/plugin-updater

// src-tauri/src/lib.rs
tauri::Builder::default()
    .plugin(tauri_plugin_updater::Builder::new().build())
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

// tauri.conf.json
{
    "plugins": {
        "updater": {
            "active": true,
            "endpoints": [
                "https://releases.myapp.com/{{target}}/{{arch}}/{{current_version}}"
            ],
            "pubkey": "your-public-key",
            "windows": {
                "installMode": "passive"
            }
        }
    }
}

{
    "endpoints": [
        "https://releases.myapp.com/{{target}}/{{arch}}/{{current_version}}",
        "https://backup.myapp.com/{{target}}/{{arch}}/{{current_version}}"
    ]
}

{
    "windows": {
        "installMode": "passive"  // passive, basic, quiet
    }
}

{
    "version": "1.1.0",
    "notes": "Bug fixes and performance improvements",
    "pub_date": "2024-01-15T12:00:00Z",
    "platforms": {
        "darwin-x86_64": {
            "signature": "dW50cnVzdGVkIGNvbW1lbnQ6IHNpZ25hdHVyZSBmcm9tIHRhdXJpIHNlY3JldCBrZXkK...",
            "url": "https://releases.myapp.com/v1.1.0/myapp_x64.app.tar.gz"
        },
        "darwin-aarch64": {
            "signature": "...",
            "url": "https://releases.myapp.com/v1.1.0/myapp_aarch64.app.tar.gz"
        },
        "windows-x86_64": {
            "signature": "...",
            "url": "https://releases.myapp.com/v1.1.0/myapp_x64-setup.nsis.zip"
        },
        "linux-x86_64": {
            "signature": "...",
            "url": "https://releases.myapp.com/v1.1.0/myapp_amd64.AppImage.tar.gz"
        }
    }
}

releases/
├── latest.json
├── darwin-x86_64/
│   └── myapp.app.tar.gz
├── darwin-aarch64/
│   └── myapp.app.tar.gz
├── windows-x86_64/
│   └── myapp-setup.nsis.zip
└── linux-x86_64/
    └── myapp.AppImage.tar.gz

{
    "endpoints": [
        "https://github.com/user/repo/releases/latest/download/{{target}}-{{arch}}.json"
    ]
}

import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';

async function checkForUpdates() {
    const update = await check();
    
    if (update) {
        console.log('Update available:', update.version);
        return update;
    }
    
    console.log('No updates available');
    return null;
}

import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';

async function updateApp() {
    const update = await check();
    
    if (!update) {
        return false;
    }
    
    let downloaded = 0;
    let contentLength = 0;
    
    await update.downloadAndInstall((event) => {
        switch (event.event) {
            case 'Started':
                contentLength = event.data.contentLength;
                console.log(`Started downloading ${contentLength} bytes`);
                break;
            case 'Progress':
                downloaded += event.data.chunkLength;
                const progress = (downloaded / contentLength) * 100;
                console.log(`Downloaded ${progress.toFixed(1)}%`);
                break;
            case 'Finished':
                console.log('Download finished');
                break;
        }
    });
    
    console.log('Update installed, restarting...');
    await relaunch();
}

import { useState, useCallback } from 'react';
import { check, Update } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';

export function useUpdater() {
    const [update, setUpdate] = useState<Update | null>(null);
    const [downloading, setDownloading] = useState(false);
    const [progress, setProgress] = useState(0);

    const checkForUpdates = useCallback(async () => {
        const result = await check();
        setUpdate(result);
        return result;
    }, []);

    const downloadAndInstall = useCallback(async () => {
        if (!update) return;

        setDownloading(true);
        setProgress(0);

        let downloaded = 0;
        let contentLength = 0;

        await update.downloadAndInstall((event) => {
            switch (event.event) {
                case 'Started':
                    contentLength = event.data.contentLength;
                    break;
                case 'Progress':
                    downloaded += event.data.chunkLength;
                    setProgress((downloaded / contentLength) * 100);
                    break;
                case 'Finished':
                    break;
            }
        });

        setDownloading(false);
        await relaunch();
    }, [update]);

    return {
        update,
        downloading,
        progress,
        checkForUpdates,
        downloadAndInstall,
    };
}

import { useUpdater } from '../hooks/useUpdater';

export function UpdateNotification() {
    const { update, downloading, progress, checkForUpdates, downloadAndInstall } = useUpdater();

    useEffect(() => {
        checkForUpdates();
    }, []);

    if (!update) return null;

    return (
        <div className="update-notification">
            <p>发现新版本 {update.version}</p>
            {downloading ? (
                <div className="progress">
                    <div className="progress-bar" style={{ width: `${progress}%` }} />
                </div>
            ) : (
                <button onClick={downloadAndInstall}>立即更新</button>
            )}
        </div>
    );
}

# 生成私钥
tauri signer generate -w ~/.tauri/myapp.key

# 查看公钥
tauri signer sign --private-key-path ~/.tauri/myapp.key

{
    "plugins": {
        "updater": {
            "pubkey": "your-public-key-here"
        }
    }
}

# 设置环境变量
export TAURI_SIGNING_PRIVATE_KEY="your-private-key"
export TAURI_SIGNING_PRIVATE_KEY_PASSWORD="your-password"

# 构建
pnpm tauri build

import { check } from '@tauri-apps/plugin-updater';

async function setupAutoCheck() {
    // 启动时检查
    await checkForUpdates();

    // 定期检查（每小时）
    setInterval(async () => {
        await checkForUpdates();
    }, 60 * 60 * 1000);
}

async function checkForUpdates() {
    const update = await check();

    if (update && update.shouldUpdate) {
        // 强制更新
        await update.downloadAndInstall();
        await relaunch();
    }
}

// 检查是否支持增量更新
if (update.supportsDeltaUpdate) {
    // 使用增量更新
    await update.downloadAndInstall();
} else {
    // 完整更新
    await update.downloadAndInstall();
}

async function notifyUpdate(update: Update) {
    const { ask } = await import('@tauri-apps/plugin-dialog');

    const confirmed = await ask(
        `发现新版本 ${update.version}，是否立即更新？`,
        { title: '更新可用', kind: 'info' }
    );

    if (confirmed) {
        await update.downloadAndInstall();
        await relaunch();
    }
}

async function safeUpdate() {
    try {
        const update = await check();

        if (!update) return;

        await update.downloadAndInstall((event) => {
            // 处理进度
        });

        await relaunch();
    } catch (error) {
        console.error('Update failed:', error);
        // 显示错误信息
    }
}

function compareVersions(current: string, latest: string): number {
    const currentParts = current.split('.').map(Number);
    const latestParts = latest.split('.').map(Number);

    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
        const currentPart = currentParts[i] || 0;
        const latestPart = latestParts[i] || 0;

        if (latestPart > currentPart) return 1;
        if (latestPart < currentPart) return -1;
    }

    return 0;
}