Skip to content

PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.

23.4 KB
Raw Blame
// pasteferry-cli 是开发调试用的命令行客户端。
//
// 它走与 Flutter UI 完全相同的 gRPC 接口,因此既能在 UI 就绪前验证 daemon,
// 也能在之后用来区分「是 daemon 的问题还是 UI 的问题」。
//
//	pasteferry-cli status              查看 daemon 状态
//	pasteferry-cli watch               订阅事件流
//	pasteferry-cli history             列出历史记录
//	pasteferry-cli config              查看配置
//	pasteferry-cli devices             列出已配对设备
//	pasteferry-cli nat                 网络出口、局域网与各设备连接情况
//	pasteferry-cli pair                生成配对码
//	pasteferry-cli join CODE [ADDRESS] 兑换配对码;不在同一网段时带上对方显示的地址
//	pasteferry-cli nearby [NAME]       搜索附近设备:给了 NAME 就在它出现时向它发起配对,否则等对方点本机
//	pasteferry-cli address DEVICE ADDR 手动指定某台设备的地址
//	pasteferry-cli send [-relay] DEVICE PATH...  隔空传送:把文件或文件夹发给一台设备
//	pasteferry-cli transfers [-v]      最近收到和发出的文件(-v 带上 ID)
//	pasteferry-cli cancel ID           取消一批传输
//	pasteferry-cli web [on|off|invite [ADDR]|remove ID]  手机网页传输
//	pasteferry-cli mcp                 MCP 服务(stdio):让 AI 读、改、应用主题,见 design/mcp.md
package main

import (
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/metadata"

	"github.com/baiyuze/pasteferry/client-core/internal/config"
	"github.com/baiyuze/pasteferry/client-core/internal/rpc"
	pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
)

// version is set by the packaging scripts for every supported platform.
var version = "dev"
var jsonOutput bool

func reportError(err error, code int) {
	if jsonOutput {
		_ = json.NewEncoder(os.Stdout).Encode(map[string]any{"ok": false, "error": err.Error()})
	} else {
		fmt.Fprintln(os.Stderr, "错误:", err)
	}
	os.Exit(code)
}

func main() {
	flag.CommandLine = flag.NewFlagSet("pasteferry-cli", flag.ContinueOnError)
	flag.CommandLine.SetOutput(io.Discard)
	flag.BoolVar(&jsonOutput, "json", false, "以 JSON 输出只读查询结果")
	dataDir := flag.String("data-dir", "", "数据目录(默认为系统标准位置)")
	if err := flag.CommandLine.Parse(os.Args[1:]); err != nil {
		if errors.Is(err, flag.ErrHelp) {
			if jsonOutput {
				if err := writeJSON(map[string]string{"usage": "pasteferry-cli [-json] [-data-dir DIR] <version|status|devices|history|config [get]>"}); err != nil {
					reportError(err, 1)
				}
				return
			}
			fmt.Println("用法: pasteferry-cli [-json] [-data-dir DIR] <version|status|devices|history|config [get]|...>")
			return
		}
		reportError(err, 2)
	}

	cmd := flag.Arg(0)
	if cmd == "" {
		if jsonOutput {
			reportError(errors.New("缺少命令:version、status、devices、history 或 config get"), 2)
		}
		fmt.Fprintln(os.Stderr,
			"用法: pasteferry-cli [-json] [-data-dir DIR] <version|status|watch|history|config [get]|devices|nat|pair|join CODE [ADDRESS]|nearby [NAME]|address DEVICE ADDR|send [-relay] [-note TEXT] DEVICE PATH...|transfers [-v]|cancel ID|friends|friend code|add|remove|auto|accept [ID] [always]|decline [ID]|name NAME|avatar PATH|reset|receive-from [off|friends|everyone]|web [on|off|invite [ADDR]|remove ID]|mcp>")
		os.Exit(2)
	}

	if err := run(cmd, *dataDir); err != nil {
		reportError(err, 1)
	}
}

func run(cmd, dataDir string) error {
	if jsonOutput {
		if err := validateJSONCommand(cmd); err != nil {
			return err
		}
	}
	if cmd == "version" {
		if flag.NArg() != 1 {
			return errors.New("用法: pasteferry-cli version")
		}
		if jsonOutput {
			return writeJSON(map[string]string{"version": version})
		}
		fmt.Println(version)
		return nil
	}
	if cmd == "config" && (flag.NArg() > 2 || (flag.NArg() == 2 && flag.Arg(1) != "get")) {
		return errors.New("用法: pasteferry-cli config [get]")
	}
	paths, err := resolvePaths(dataDir)
	if err != nil {
		return err
	}
	// MCP 服务不要求后台服务已经在跑:每次调用工具时才去连
	if cmd == "mcp" {
		if flag.NArg() != 1 {
			return errors.New("用法: pasteferry-cli mcp")
		}
		return serveMCP(os.Stdin, os.Stdout, os.Stderr, daemonDialer(paths))
	}

	ep, err := rpc.ReadEndpoint(paths.Endpoint)
	if err != nil {
		if os.IsNotExist(err) {
			return fmt.Errorf("daemon 未运行(找不到 %s)", paths.Endpoint)
		}
		return err
	}

	conn, err := grpc.NewClient(fmt.Sprintf("127.0.0.1:%d", ep.Port),
		grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		return fmt.Errorf("连接 daemon: %w", err)
	}
	defer conn.Close()

	client := pb.NewDaemonServiceClient(conn)
	// token 随每次调用发送,daemon 侧用常数时间比较校验
	ctx := metadata.AppendToOutgoingContext(context.Background(), "x-pasteferry-token", ep.Token)
	if jsonOutput {
		return queryJSON(ctx, client, ep, cmd)
	}

	switch cmd {
	case "status":
		return showStatus(ctx, client, ep)
	case "watch":
		return watch(ctx, client)
	case "history":
		return showHistory(ctx, client)
	case "config":
		return showConfig(ctx, client)
	case "devices":
		return showDevices(ctx, client)
	case "nat":
		return showNetwork(ctx, client)
	case "pair":
		return createPairing(ctx, client)
	case "join":
		return joinPairing(ctx, client, flag.Arg(1), flag.Arg(2))
	case "nearby":
		return nearbyPairing(ctx, client, flag.Arg(1))
	case "address":
		return setAddress(ctx, client, flag.Arg(1), flag.Arg(2))
	case "send":
		return sendFiles(ctx, client, flag.Args()[1:])
	case "transfers":
		return showTransfers(ctx, client, flag.Arg(1) == "-v")
	case "cancel":
		return cancelTransfer(ctx, client, flag.Arg(1))
	case "friends":
		return showFriends(ctx, client)
	case "friend":
		return friendCommand(ctx, client, flag.Args()[1:])
	case "accept":
		return answerIncoming(ctx, client, flag.Arg(1), true, flag.Arg(2) == "always")
	case "decline":
		return answerIncoming(ctx, client, flag.Arg(1), false, false)
	case "name":
		return setName(ctx, client, flag.Arg(1))
	case "avatar":
		return setAvatar(ctx, client, flag.Arg(1))
	case "strangers":
		return showStrangers(ctx, client)
	case "receive-from":
		return setReceiveFrom(ctx, client, flag.Arg(1))
	case "web":
		return webShare(ctx, client, flag.Args()[1:])
	default:
		return fmt.Errorf("未知命令 %q", cmd)
	}
}

func showDevices(ctx context.Context, c pb.DaemonServiceClient) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	resp, err := c.ListDevices(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	self := resp.GetSelf()
	fmt.Printf("本机  %s  %s\n", self.GetName(), self.GetPublicKeyFingerprint())
	fmt.Printf("      %s\n\n", self.GetId())

	if len(resp.GetPeers()) == 0 {
		fmt.Println("(尚未配对任何设备,用 pair / join 建立配对)")
		return nil
	}
	for _, p := range resp.GetPeers() {
		fmt.Printf("%-16s %-10s %-8s %-10s %s\n",
			p.GetName(), p.GetPlatform(),
			connectionLabel(p), receiveLabel(p), p.GetPublicKeyFingerprint())
	}
	return nil
}

// receiveLabel 是对方能不能收隔空传送,后面带上它声明的版本号。
// 还没收到它的功能声明时只能说「未知」,不能当成旧版本
func receiveLabel(d *pb.Device) string {
	label := "收文件"
	switch {
	case !d.GetFeaturesKnown() && !d.GetReceivesFiles():
		return "未知"
	case !d.GetReceivesFiles():
		return "需要更新"
	case d.GetReceiveDisabled():
		label = "不收文件"
	}
	if v := d.GetAppVersion(); v != "" {
		label += " " + v
	}
	return label
}

// connectionLabel 区分直连与中转,便于排查网络问题:
// 一直显示「中转」说明 NAT 打洞没成功,走的是服务器带宽。
func connectionLabel(d *pb.Device) string {
	if !d.GetOnline() {
		return "离线"
	}
	switch d.GetConnection() {
	case pb.ConnectionKind_CONNECTION_KIND_DIRECT:
		return "直连"
	case pb.ConnectionKind_CONNECTION_KIND_RELAY:
		return "中转"
	default:
		return "在线"
	}
}

// createPairing 生成配对码并等待对方兑换。
func createPairing(ctx context.Context, c pb.DaemonServiceClient) error {
	// 先订阅事件流,才能在对方兑换后收到设备变化通知
	streamCtx, cancel := context.WithCancel(ctx)
	defer cancel()
	stream, err := c.Subscribe(streamCtx, &pb.SubscribeRequest{})
	if err != nil {
		return err
	}

	createCtx, createCancel := context.WithTimeout(ctx, 15*time.Second)
	resp, err := c.CreatePairingCode(createCtx, &pb.Empty{})
	createCancel()
	if err != nil {
		return err
	}

	fmt.Printf("\n  配对码:%s\n", resp.GetCode())
	fmt.Printf("  有效期至 %s\n", time.Unix(resp.GetExpiresAtUnix(), 0).Format("15:04:05"))
	if addrs := resp.GetLanAddresses(); len(addrs) > 0 {
		fmt.Printf("  本机地址:%s\n", strings.Join(addrs, "  "))
	}
	fmt.Println("\n  在另一台设备上运行:pasteferry-cli join " + resp.GetCode())
	if addrs := resp.GetLanAddresses(); len(addrs) > 0 {
		fmt.Printf("  不在同一网段时:pasteferry-cli join %s %s\n", resp.GetCode(), addrs[0])
	}
	fmt.Println("  等待对方兑换…(Ctrl+C 取消)")

	for {
		ev, err := stream.Recv()
		if err != nil {
			return err
		}
		d := ev.GetDeviceChanged()
		if d == nil || d.GetPairingSession() == "" {
			continue // 非待确认的配对事件(普通的在线状态变化)
		}
		fmt.Printf("\n  对方已兑换:%s(%s)\n", d.GetName(), d.GetPlatform())
		return confirmPeer(ctx, c, d, d.GetPairingSession())
	}
}

// confirmPeer 打印两行安全指纹,问用户是否一致,把回答告诉后台服务。
func confirmPeer(ctx context.Context, c pb.DaemonServiceClient, peer *pb.Device, session string) error {
	if err := printFingerprints(ctx, c, peer); err != nil {
		return err
	}
	fmt.Print("  确认配对?[y/N] ")

	var answer string
	fmt.Scanln(&answer)
	accept := answer == "y" || answer == "Y"

	confirmCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()
	if _, err := c.ConfirmPairing(confirmCtx, &pb.ConfirmPairingRequest{
		PairingSession: session,
		Accept:         accept,
	}); err != nil {
		return err
	}
	if accept {
		fmt.Println("\n  ✓ 配对成功")
	} else {
		fmt.Println("\n  已取消")
	}
	return nil
}

// printFingerprints 打印配对时要核对的两行:本机与对方的公钥指纹,按指纹排序。
// 两台设备打印出的内容完全相同,用户比对两块屏幕即可;规则与界面一致
// (见 ui/lib/widgets/pairing_dialog.dart 的 pairingFingerprintRows)。
func printFingerprints(ctx context.Context, c pb.DaemonServiceClient, peer *pb.Device) error {
	resp, err := c.ListDevices(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	rows := []*pb.Device{resp.GetSelf(), peer}
	sort.Slice(rows, func(i, j int) bool {
		return rows[i].GetPublicKeyFingerprint() < rows[j].GetPublicKeyFingerprint()
	})
	fmt.Println("  安全指纹:")
	for _, d := range rows {
		fmt.Printf("    %s  %s\n", d.GetPublicKeyFingerprint(), d.GetName())
	}
	fmt.Println("\n  两台设备上显示的这两行应当完全相同,一致才继续。")
	return nil
}

// showNetwork 打印后台服务最近一轮的网络出口探测结果,以及各设备当前走直连还是中转。
// 看的是后台服务实际在用的数据,而不是另起炉灶再测一遍。
func showNetwork(ctx context.Context, c pb.DaemonServiceClient) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	info, err := c.GetNetwork(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	when := "尚未探测"
	if info.GetProbedAtUnix() > 0 {
		when = time.Unix(info.GetProbedAtUnix(), 0).Format("15:04:05")
	}
	fmt.Printf("打洞端口  %d(UDP)\n", info.GetLocalPort())
	fmt.Printf("最近探测  %s,%d 个服务器中 %d 个响应\n\n", when, info.GetProbed(), info.GetAnswered())

	measured := 0
	for _, e := range info.GetEgresses() {
		mode := "改端口  "
		if e.GetPortPreserved() {
			mode = "不改端口"
		}
		source := strings.Join(e.GetVia(), ", ")
		if e.GetGuessed() {
			source = "按历史推算"
		} else {
			measured++
		}
		fmt.Printf("  %-22s %s  %s\n", e.GetAddress(), mode, source)
	}
	switch n := len(info.GetEgresses()); {
	case n == 0:
		fmt.Println("  没有探测到出口:UDP 可能被拦截,设备之间只能走中转。")
	case n == 1:
		fmt.Println("\n单一出口。")
	default:
		fmt.Printf("\n%d 个出口:这是多出口网络。每个出口的地址都会发给对端,由对端逐个尝试。\n", n)
	}
	if measured > 0 && measured < len(info.GetEgresses()) {
		fmt.Println("按历史推算的出口这一轮没探测到,但它不改端口,地址可以推算出来。")
	}

	showLAN(info.GetLan())

	devs, err := c.ListDevices(ctx, &pb.Empty{})
	if err != nil {
		return nil
	}
	if peers := devs.GetPeers(); len(peers) > 0 {
		fmt.Println("\n设备连接:")
		for _, p := range peers {
			fmt.Printf("  %-18s %s\n", p.GetName(), connectionLabel(p))
		}
	}
	return nil
}

// showLAN 打印局域网直连的情况:本机在哪个端口、发现了几个实例、各设备在局域网里能否找到。
func showLAN(lan *pb.LanInfo) {
	if lan == nil {
		return
	}
	fmt.Println()
	if !lan.GetEnabled() {
		fmt.Println("局域网    已关闭")
		return
	}
	fmt.Printf("局域网    端口 %d(UDP),本机地址 %s\n", lan.GetPort(), strings.Join(lan.GetLocalAddresses(), "  "))
	fmt.Printf("          mDNS 发现了 %d 个 PasteFerry(含未配对的)\n", lan.GetDiscovered())
	if lan.GetBlocked() {
		fmt.Println("          系统拦下了发往局域网的包:到「系统设置 → 隐私与安全性 → 本地网络」里打开 PasteFerry")
	}
	for _, p := range lan.GetPeers() {
		state := "找不到"
		if p.GetReachable() {
			state = "可达 " + p.GetAddress()
		}
		fmt.Printf("  %-18s %s\n", p.GetDeviceName(), state)
		if known := p.GetKnownAddresses(); len(known) > 0 {
			fmt.Printf("  %-18s 记住的地址 %s\n", "", strings.Join(known, "  "))
		}
	}
}

func setAddress(ctx context.Context, c pb.DaemonServiceClient, device, addr string) error {
	if device == "" || addr == "" {
		return errors.New("用法: pasteferry-cli address <设备名或 ID> <地址>")
	}
	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()
	devs, err := c.ListDevices(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	id := ""
	for _, p := range devs.GetPeers() {
		if p.GetId() == device || p.GetName() == device {
			id = p.GetId()
		}
	}
	if id == "" {
		return fmt.Errorf("没有叫 %q 的已配对设备", device)
	}
	if _, err := c.SetDeviceAddress(ctx, &pb.SetDeviceAddressRequest{DeviceId: id, Address: addr}); err != nil {
		return err
	}
	fmt.Println("已记下,正在那个地址上找它;用 pasteferry-cli nat 查看结果")
	return nil
}

func joinPairing(ctx context.Context, c pb.DaemonServiceClient, code, address string) error {
	if code == "" {
		return errors.New("用法: pasteferry-cli join <配对码> [对方地址]")
	}
	ctx, cancel := context.WithTimeout(ctx, 20*time.Second)
	defer cancel()

	resp, err := c.RedeemPairingCode(ctx, &pb.RedeemPairingCodeRequest{Code: code, Address: address})
	if err != nil {
		return err
	}
	peer := resp.GetPeer()
	fmt.Printf("\n  找到设备:%s(%s)\n", peer.GetName(), peer.GetPlatform())
	return confirmPeer(ctx, c, peer, resp.GetPairingSession())
}

// nearbyPairing 打开「搜索附近设备」,列出附近同样打开了的设备,直到配对完成或 Ctrl+C。
// 给了 target(设备名或实例名)时,它一出现就向它发起配对;没给时等对方点本机。
// 期间本机在局域网里公开设备名,与界面上开着这个窗口一样。
func nearbyPairing(ctx context.Context, c pb.DaemonServiceClient, target string) error {
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	events, err := c.Subscribe(ctx, &pb.SubscribeRequest{})
	if err != nil {
		return err
	}
	nearby, err := c.WatchNearby(ctx, &pb.Empty{})
	if err != nil {
		return err
	}

	requests := make(chan *pb.Device, 1)
	go func() {
		for {
			ev, err := events.Recv()
			if err != nil {
				return
			}
			if d := ev.GetDeviceChanged(); d != nil && d.GetPairingSession() != "" {
				select {
				case requests <- d:
				default:
				}
			}
		}
	}()
	lists := make(chan []*pb.NearbyDevice)
	lost := make(chan error, 1)
	go func() {
		for {
			msg, err := nearby.Recv()
			if err != nil {
				lost <- err
				return
			}
			select {
			case lists <- msg.GetDevices():
			case <-ctx.Done():
				return
			}
		}
	}()

	fmt.Println("\n  正在搜索附近的设备…(Ctrl+C 取消)")
	for {
		select {
		case err := <-lost:
			return err
		case list := <-lists:
			printNearby(list)
			for _, d := range list {
				if target == "" || d.GetPaired() || (d.GetName() != target && d.GetId() != target) {
					continue
				}
				pairCtx, pairCancel := context.WithTimeout(ctx, 20*time.Second)
				resp, err := c.PairNearby(pairCtx, &pb.PairNearbyRequest{Id: d.GetId()})
				pairCancel()
				if err != nil {
					return err
				}
				fmt.Printf("\n  %s 已回应\n", d.GetName())
				return confirmPeer(ctx, c, resp.GetPeer(), resp.GetPairingSession())
			}
		case d := <-requests:
			fmt.Printf("\n  %s(%s)请求配对\n", d.GetName(), d.GetPlatform())
			return confirmPeer(ctx, c, d, d.GetPairingSession())
		}
	}
}

func printNearby(list []*pb.NearbyDevice) {
	fmt.Printf("\n  %s 附近的设备:\n", time.Now().Format("15:04:05"))
	if len(list) == 0 {
		fmt.Println("    (没有。另一台也要打开「搜索附近设备」)")
	}
	for _, d := range list {
		note := d.GetId()
		if d.GetPaired() {
			note = "已配对"
		}
		fmt.Printf("    %-24s %-8s %s\n", d.GetName(), d.GetPlatform(), note)
	}
}

func resolvePaths(dataDir string) (config.Paths, error) {
	if dataDir != "" {
		abs, err := filepath.Abs(dataDir)
		if err != nil {
			return config.Paths{}, err
		}
		return config.PathsUnder(abs), nil
	}
	return config.DefaultPaths()
}

func showStatus(ctx context.Context, c pb.DaemonServiceClient, ep rpc.Endpoint) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	st, err := c.GetStatus(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	fmt.Printf("daemon      PID %d  端口 %d  版本 %s\n", ep.PID, ep.Port, st.GetVersion())
	fmt.Printf("设备        %s\n", st.GetDeviceName())
	fmt.Printf("设备 ID     %s\n", st.GetDeviceId())
	server := "未设置(只在局域网里同步)"
	if st.GetServerConfigured() {
		server = boolText(st.GetSignalingConnected(), "已连接", "未连接")
	}
	fmt.Printf("服务器      %s\n", server)
	lan := boolText(st.GetLanEnabled(), "开启", "关闭")
	if st.GetLanBlocked() {
		lan += "(被系统拦截,需要允许本地网络访问)"
	}
	fmt.Printf("局域网      %s\n", lan)
	fmt.Printf("在线对端    %d\n", st.GetPeersOnline())
	fmt.Printf("剪贴板授权  %s\n", st.GetClipboardPermission())
	fmt.Printf("缓存占用    %s\n", humanBytes(st.GetCacheBytesUsed()))
	if u := st.GetOfficialUsage(); u != nil {
		switch {
		case u.GetUpdatedAtUnix() == 0 && u.GetReason() == "":
			fmt.Println("官方额度    正在获取")
		case u.GetUpdatedAtUnix() == 0:
			fmt.Printf("官方额度    暂时获取不到(%s)\n", u.GetReason())
		default:
			// 网关按十进制 MB 计量,与界面显示一致
			mb := func(n int64) string { return fmt.Sprintf("%.2f MB", float64(n)/1e6) }
			line := fmt.Sprintf("剩余 %s / 每日 %s,已用 %s(上传 %s,下载 %s)", mb(u.GetRemainingBytes()), mb(u.GetLimitBytes()),
				mb(u.GetUploadBytes()+u.GetDownloadBytes()), mb(u.GetUploadBytes()), mb(u.GetDownloadBytes()))
			if u.GetReason() != "" {
				line += "," + u.GetReason()
			}
			fmt.Printf("官方额度    %s,更新于 %s\n", line, time.Unix(u.GetUpdatedAtUnix(), 0).Format("15:04:05"))
		}
	}
	return nil
}

func watch(ctx context.Context, c pb.DaemonServiceClient) error {
	stream, err := c.Subscribe(ctx, &pb.SubscribeRequest{})
	if err != nil {
		return err
	}
	fmt.Println("已订阅事件流,Ctrl+C 退出")
	for {
		ev, err := stream.Recv()
		if errors.Is(err, io.EOF) {
			fmt.Println("流已结束")
			return nil
		}
		if err != nil {
			return err
		}
		printEvent(ev)
	}
}

func printEvent(ev *pb.Event) {
	ts := time.Now().Format("15:04:05")
	switch p := ev.GetPayload().(type) {
	case *pb.Event_ClipAdded:
		r := p.ClipAdded
		fmt.Printf("[%s] + 新记录  %s  %s  %s  %q\n", ts,
			r.GetKind(), r.GetStatus(), humanBytes(r.GetTotalSize()), r.GetTextPreview())
	case *pb.Event_ClipUpdated:
		r := p.ClipUpdated
		fmt.Printf("[%s] ~ 更新    %s  %s\n", ts, r.GetId(), r.GetStatus())
	case *pb.Event_ClipRemoved:
		fmt.Printf("[%s] - 删除    %s\n", ts, p.ClipRemoved)
	case *pb.Event_Progress:
		pr := p.Progress
		fmt.Printf("[%s] ↓ 进度    %s  %s/%s\n", ts, pr.GetClipId(),
			humanBytes(pr.GetTransferred()), humanBytes(pr.GetTotal()))
	case *pb.Event_DeviceChanged:
		d := p.DeviceChanged
		fmt.Printf("[%s] ⇄ 设备    %s  %s  %s\n", ts,
			d.GetName(), boolText(d.GetOnline(), "在线", "离线"), d.GetConnection())
	case *pb.Event_PermissionChanged:
		fmt.Printf("[%s] ! 授权    %s\n", ts, p.PermissionChanged)
	case *pb.Event_StatusChanged:
		s := p.StatusChanged
		fmt.Printf("[%s] i 状态    信令=%v 对端=%d 授权=%s\n", ts,
			s.GetSignalingConnected(), s.GetPeersOnline(), s.GetClipboardPermission())
	default:
		fmt.Printf("[%s] ? 未知事件 %T\n", ts, p)
	}
}

func showHistory(ctx context.Context, c pb.DaemonServiceClient) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	resp, err := c.ListHistory(ctx, &pb.ListHistoryRequest{Limit: 20})
	if err != nil {
		return err
	}
	if len(resp.GetRecords()) == 0 {
		fmt.Println("(暂无记录)")
		return nil
	}
	for _, r := range resp.GetRecords() {
		dir := "←收到"
		if r.GetOutgoing() {
			dir = "→本机"
		}
		fmt.Printf("%s  %s  %-6s %-14s %8s  %s\n",
			time.Unix(r.GetCreatedAtUnix(), 0).Format("01-02 15:04:05"),
			dir, r.GetKind(), r.GetStatus(),
			humanBytes(r.GetTotalSize()), preview(r))
	}
	return nil
}

func preview(r *pb.ClipRecord) string {
	if t := r.GetTextPreview(); t != "" {
		return fmt.Sprintf("%q", t)
	}
	switch n := len(r.GetItems()); n {
	case 0:
		return ""
	case 1:
		return r.GetItems()[0].GetName()
	default:
		return fmt.Sprintf("%s 等 %d 项", r.GetItems()[0].GetName(), n)
	}
}

func showConfig(ctx context.Context, c pb.DaemonServiceClient) error {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	cfg, err := c.GetConfig(ctx, &pb.Empty{})
	if err != nil {
		return err
	}
	fmt.Printf("设备名称      %s\n", cfg.GetDeviceName())
	server := cfg.GetSignalingUrl()
	if server == "" {
		server = "(未设置)"
	}
	fmt.Printf("信令地址      %s\n", server)
	fmt.Printf("局域网发现    %v\n", !cfg.GetLanDisabled())
	fmt.Printf("自动同步阈值  %s\n", humanBytes(cfg.GetAutoSyncThresholdBytes()))
	fmt.Printf("历史保留      %s\n", time.Duration(cfg.GetHistoryTtlSeconds())*time.Second)
	fmt.Printf("缓存保留      %s\n", time.Duration(cfg.GetCacheTtlSeconds())*time.Second)
	fmt.Printf("同步类型      文本=%v HTML=%v 图片=%v 文件=%v\n",
		cfg.GetSyncText(), cfg.GetSyncHtml(), cfg.GetSyncImage(), cfg.GetSyncFile())
	fmt.Printf("自动写剪贴板  %v\n", cfg.GetAutoApplyToClipboard())
	return nil
}

func boolText(b bool, yes, no string) string {
	if b {
		return yes
	}
	return no
}

func humanBytes(n int64) string {
	const unit = 1024
	if n < unit {
		return fmt.Sprintf("%d B", n)
	}
	div, exp := int64(unit), 0
	for v := n / unit; v >= unit; v /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %ciB", float64(n)/float64(div), "KMGTPE"[exp])
}