omni-dev 0.32.0

AI-powered git commit rewriter, PR generator, and MCP server for Jira, Confluence, and Datadog.
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

//! `omni-dev daemon run` — become the daemon (foreground).

use std::path::PathBuf;

use anyhow::Result;
use clap::Parser;

use crate::browser::bridge::{DEFAULT_CONTROL_PORT, DEFAULT_WS_PORT};
use crate::browser::BridgeConfig;
use crate::daemon::server;
use crate::daemon::{self, paths, DaemonRunConfig};

/// Runs the daemon in the foreground.
///
/// Acquires the control socket — the service-manager-activated fd when the daemon
/// is socket-activated (launchd on macOS, systemd on Linux), otherwise a self-bound
/// socket (which doubles as the single-instance lock) — starts every registered
/// service (including the browser bridge on its loopback-TCP planes), and blocks
/// until `SIGTERM`/`SIGINT` or a `daemon stop`. This is the process the service
/// manager demand-spawns on the first client connect (or that `daemon start`
/// warms).
///
/// On a macOS build with the `menu-bar` feature, this also shows the menu-bar
/// tray unless `--no-menu` is given.
#[derive(Parser, Clone)]
pub struct RunCommand {
    /// Control-socket path. Defaults to the per-user runtime location.
    #[arg(long, value_name = "PATH")]
    pub socket: Option<PathBuf>,

    /// Browser-bridge WebSocket-plane port (`0` binds a random free port).
    #[arg(long, default_value_t = DEFAULT_WS_PORT)]
    pub bridge_ws_port: u16,

    /// Browser-bridge HTTP control-plane port (`0` binds a random free port).
    #[arg(long, default_value_t = DEFAULT_CONTROL_PORT)]
    pub bridge_control_port: u16,

    /// Permit a cross-origin for the bridge's WebSocket upgrade and outbound
    /// URLs (the bridge's `--allow-origin`). Repeatable and scoped per connecting
    /// tab: a bare `ORIGIN`, or a `CONNECT=OUTBOUND` mapping.
    #[arg(long, value_name = "URL[=URL]")]
    pub bridge_allow_origin: Vec<String>,

    /// Read the bridge session token from this `0600` file instead of
    /// generating one.
    #[arg(long, value_name = "PATH")]
    pub bridge_token_file: Option<PathBuf>,

    /// Run headless: never show the macOS menu-bar tray (no effect on non-macOS
    /// or non-`menu-bar` builds, which are always headless).
    #[arg(long)]
    pub no_menu: bool,
}

impl RunCommand {
    /// Executes the run command (headless; the menu-bar path is selected in
    /// `main`, which hands the main thread to the tray).
    pub async fn execute(self) -> Result<()> {
        daemon::run_headless(self.into_run_config()?).await
    }

    /// Resolves the CLI flags into a [`DaemonRunConfig`]. Shared by the headless
    /// `execute` path and the macOS menu-bar path.
    pub fn into_run_config(self) -> Result<DaemonRunConfig> {
        let socket_path = server::resolve_socket(self.socket)?;
        let bridge_token_path = paths::token_path_for_socket(&socket_path);
        let allow_origins = crate::browser::auth::OriginAllowlist::parse(&self.bridge_allow_origin)
            .map_err(|e| anyhow::anyhow!("invalid --bridge-allow-origin: {e}"))?;
        let bridge_config = BridgeConfig {
            ws_port: self.bridge_ws_port,
            control_port: self.bridge_control_port,
            allow_origins,
            ..BridgeConfig::default()
        };
        Ok(DaemonRunConfig {
            socket_path,
            bridge_config,
            bridge_token_file: self.bridge_token_file,
            bridge_token_path,
        })
    }
}