xbp 10.43.0

XBP is a zero-config build pack that can also interact with proxies, kafka, sockets, synthetic monitors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::cli::commands;
use crate::cli::error::{CliResult, ErrorFactory};
use crate::commands::{
    is_tray_background_child, resolve_default_worktree_watch_status_target,
    run_worktree_watch_start, run_worktree_watch_status, run_worktree_watch_stop,
    run_worktree_watch_sync, run_worktree_watch_tray, spawn_detached_worktree_watch_tray,
    WorktreeWatchStartOptions, WorktreeWatchStatusOptions, WorktreeWatchStopOptions,
    WorktreeWatchSyncOptions, WorktreeWatchTargetOptions, WorktreeWatchTrayOptions,
};

fn map_target(target: commands::WorktreeWatchTarget) -> Result<WorktreeWatchTargetOptions, String> {
    crate::commands::normalize_worktree_watch_target(WorktreeWatchTargetOptions {
        repo: target.repo,
        parent: target.parent,
        repos: target.repos,
    })
}

fn map_status_target(
    target: commands::WorktreeWatchTarget,
) -> Result<WorktreeWatchTargetOptions, String> {
    if target.repo.is_none() && target.parent.is_none() && target.repos.is_empty() {
        // Bare `status`: prefer a live parent watcher (Documents/GitHub etc.).
        return resolve_default_worktree_watch_status_target();
    }
    map_target(target)
}

pub async fn handle_worktree_watch(cmd: commands::WorktreeWatchCmd, _debug: bool) -> CliResult<()> {
    let result = match cmd.command {
        commands::WorktreeWatchSubCommand::Start(start_cmd) => match map_target(start_cmd.target)
        {
            Ok(target) => {
                run_worktree_watch_start(WorktreeWatchStartOptions {
                    target,
                    detach: start_cmd.detach,
                    sync_interval_seconds: start_cmd.sync_interval_seconds,
                    once: start_cmd.once,
                })
                .await
            }
            Err(error) => Err(error),
        },
        commands::WorktreeWatchSubCommand::Stop(stop_cmd) => match map_target(stop_cmd.target) {
            Ok(target) => run_worktree_watch_stop(WorktreeWatchStopOptions {
                target,
                force: stop_cmd.force,
            }),
            Err(error) => Err(error),
        },
        commands::WorktreeWatchSubCommand::Sync(sync_cmd) => match map_target(sync_cmd.target) {
            Ok(target) => {
                run_worktree_watch_sync(WorktreeWatchSyncOptions {
                    target,
                    dry_run: sync_cmd.dry_run,
                    resync: sync_cmd.resync,
                })
                .await
            }
            Err(error) => Err(error),
        },
        commands::WorktreeWatchSubCommand::Status(status_cmd) => {
            match map_status_target(status_cmd.target) {
                Ok(target) => {
                    run_worktree_watch_status(WorktreeWatchStatusOptions {
                        target,
                        json: status_cmd.json,
                        records: status_cmd.records,
                        record_limit: status_cmd.record_limit,
                        stats: status_cmd.stats,
                        repo_activity: status_cmd.repo_activity,
                        stats_gap_minutes: status_cmd.stats_gap_minutes,
                    })
                    .await
                }
                Err(error) => Err(error),
            }
        }
        commands::WorktreeWatchSubCommand::Tray(tray_cmd) => match map_target(tray_cmd.target) {
            Ok(target) => {
                let options = WorktreeWatchTrayOptions {
                    target,
                    sync_interval_seconds: tray_cmd.sync_interval_seconds,
                };

                if !tray_cmd.foreground && !is_tray_background_child() {
                    spawn_detached_worktree_watch_tray(options)
                } else {
                    // Tray owns a blocking native event loop (Windows NotifyIcon / Linux StatusNotifier).
                    tokio::task::spawn_blocking(move || run_worktree_watch_tray(options))
                        .await
                        .map_err(|error| format!("Worktree-watch tray task failed: {error}"))
                        .and_then(|inner| inner)
                }
            }
            Err(error) => Err(error),
        },
    };

    result.map_err(|error| {
        ErrorFactory::operation(
            "worktree-watch",
            "process worktree mutations",
            error,
            Some(
                "Run inside a git repository, pass `--repo <path|name|owner/repo>`, `--repos …`, or `--parent <folder>`. Names resolve via `~/.xbp/config.yaml` system inventory (`xbp diag --refresh-system-inventory`). Use `xbp login` before syncing.",
            ),
        )
    })
}