BREP_app 0.14.0

//! Native entry: `brep-app [--mcp [--mcp-port PORT] [--session-root DIR]]`.
//!
//! Opens a real OS window (winit, via eframe) whose wgpu device drives the
//! shared `brep-render` engine. Needs a display + GPU to actually run; on a
//! headless box this still `cargo build`s (the CI/gate signal), and the web
//! target (`lib.rs` + `WebRunner`) is the interactive verification path.
//!
//! `--mcp` embeds the MCP server (src/mcp.rs): the window becomes a session an
//! AI agent drives over `http://127.0.0.1:PORT/mcp`, and the terminal prints
//! how to configure Claude Code or Codex for it.
//!
//! `--kicad-library` is the one flag that opens a DIFFERENT window: the minimal
//! KiCad importer (`panels/kicad_library.rs`), which clones KiCad's own
//! libraries with git or reads the install on this machine, and writes each part it
//! imports into the model store as a document. No viewport, no workbench —
//! which is also why it runs where the CAD window might not.
//!
//! On Windows the executable is a GUI program (`windows_subsystem`), so a
//! Start-menu launch opens no console window beside the CAD window. Given any
//! argument it attaches to the console it was started from
//! ([`windows_console::attach_parent`]), so `--version`, `--plm-check`, the
//! other terminal commands and `--mcp`'s instructions still print there, and
//! their exit codes reach the caller. From Explorer there is no such console
//! and nothing changes.

// A GUI program on Windows: no console window of its own.
#![cfg_attr(windows, windows_subsystem = "windows")]

#[cfg(not(target_arch = "wasm32"))]
const USAGE: &str = "usage: brep-app [FILE] [--mcp] [--mcp-port PORT] [--session-root DIR] [--plm-url URL] [--plm-token-file FILE]
       brep-app --kicad-library
       brep-app --install-file-associations | --uninstall-file-associations
       brep-app --plm-configure URL [--plm-token-file FILE] | --plm-forget | --plm-show | --plm-check
       brep-app --bake-worker [--plm-url URL] [--plm-token-file FILE] [--once | --poll SECS]
       brep-app --provision-typescript | --typescript-status

  FILE                open this document in a tab at startup (what a file
                      association hands us on a double click): a part (.nbrep),
                      a family seed (.fbrep) or a template (.tbrep)
  --mcp               embed the MCP server: agents drive this window over http://127.0.0.1:PORT/mcp
  --mcp-instance NAME named persistent MCP state (default desktop; also used by the editor)
  --mcp-state-dir DIR explicit MCP journal directory
  --mcp-ephemeral     disable MCP journal persistence for this launch
  --mcp-port PORT     the port to listen on (default 8765)
  --session-root DIR  where MCP sessions keep screenshots and call logs (default: the OS temp dir)
  --provision-typescript
                      install the pinned TypeScript compiler run_script checks
                      TypeScript with, into the user-local prefix it discovers,
                      using npm (BREP_NPM or PATH); downloads, then exits
  --typescript-status report that compiler (discovery and launcher probe) and exit
  --kicad-library     open the KiCad importer instead of the CAD window: clone
                      KiCad's symbol, footprint and 3D-model libraries (git), or import
                      parts from the KiCad installed here, saving each as a document
  --install-file-associations
                      make THIS executable the opener for .nbrep, .fbrep and
                      .tbrep files, for the current user, and print what was
                      written
  --uninstall-file-associations
                      remove that association again
  --plm-url URL       connect this session to the PLM server at URL (overrides
                      BREP_PLM_URL, which overrides plm.json in the config dir)
  --plm-token-file FILE
                      read this session's PLM API token from FILE (overrides
                      BREP_PLM_TOKEN, which overrides the config dir's plm-token)
  --plm-configure URL write plm.json (and, with --plm-token-file, plm-token at mode
                      0600) into the config dir and exit: the no-prompt setup an
                      installer script runs. With no PLM configured the app is
                      the file-based app
  --plm-forget        remove plm.json and plm-token from the config dir and exit
  --plm-show          print the PLM server this launch would use, and from where,
                      and exit (the token is never printed)
  --plm-check         sign in to that server and check it serves this version of
                      the app, exactly as a window launch would, and exit: 0 when
                      it connects, 1 with the refusal when it does not
  --version           print `brep-app <version>` and exit
  --bake-worker       run as the PLM's headless bake worker, with no window:
                      build each queued family member or template copy, keep
                      it or report why it failed, one line per job. It finds
                      its server and token as --plm-url / --plm-token-file do
    --once            one pass over the queue, then exit
    --poll SECS       seconds between passes when the queue is empty (default 30)
  -h, --help          this text";

/// What the command line asked for.
#[cfg(not(target_arch = "wasm32"))]
#[derive(Debug, PartialEq, Default)]
struct Launch {
    mcp: bool,
    mcp_port: Option<u16>,
    mcp_instance: Option<String>,
    mcp_state_dir: Option<std::path::PathBuf>,
    mcp_ephemeral: bool,
    session_root: Option<std::path::PathBuf>,
    help: bool,
    /// `--version`: print the app's version and exit.
    version: bool,
    /// A document to open at startup: the positional argument, which is also
    /// what a `.desktop` `Exec=… %f` or a Windows `shell\open\command` passes.
    open: Option<std::path::PathBuf>,
    /// `Some(true)` install, `Some(false)` uninstall. Neither opens a window.
    associations: Option<bool>,
    /// Open the KiCad importer instead of the CAD window.
    kicad_library: bool,
    /// `--plm-url` / `--plm-token-file`: this launch's PLM overrides (plan D5).
    plm: brep_app::plm::config::Flags,
    /// A terminal PLM config command; none of them opens a window.
    plm_command: Option<PlmCommand>,
}

/// `--plm-configure URL`, `--plm-forget`, `--plm-show`.
#[cfg(not(target_arch = "wasm32"))]
#[derive(Debug, PartialEq)]
enum PlmCommand {
    Configure(String),
    Forget,
    Show,
    Check,
}

#[cfg(not(target_arch = "wasm32"))]
fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Launch, String> {
    let mut launch = Launch::default();
    let mut args = args.into_iter();
    while let Some(arg) = args.next() {
        match arg.as_str() {
            "--mcp" => launch.mcp = true,
            "--mcp-instance" => launch.mcp_instance = Some(args.next().ok_or("--mcp-instance needs a name")?),
            "--mcp-state-dir" => launch.mcp_state_dir = Some(args.next().ok_or("--mcp-state-dir needs a directory")?.into()),
            "--mcp-ephemeral" => launch.mcp_ephemeral = true,
            "--mcp-port" => {
                let value = args.next().ok_or("--mcp-port needs a port number")?;
                launch.mcp_port = Some(value.parse().map_err(|_| format!("--mcp-port: `{value}` is not a port number"))?);
            }
            "--session-root" => {
                launch.session_root = Some(args.next().ok_or("--session-root needs a directory")?.into());
            }
            "--kicad-library" => launch.kicad_library = true,
            "--install-file-associations" => launch.associations = Some(true),
            "--uninstall-file-associations" => launch.associations = Some(false),
            "--plm-url" => launch.plm.url = Some(args.next().ok_or("--plm-url needs the server's URL")?),
            "--plm-token-file" => {
                launch.plm.token_file = Some(args.next().ok_or("--plm-token-file needs a file")?.into());
            }
            "--plm-configure" => {
                let url = args.next().ok_or("--plm-configure needs the server's URL")?;
                set_plm_command(&mut launch, PlmCommand::Configure(url))?;
            }
            "--plm-forget" => set_plm_command(&mut launch, PlmCommand::Forget)?,
            "--plm-show" => set_plm_command(&mut launch, PlmCommand::Show)?,
            "--plm-check" => set_plm_command(&mut launch, PlmCommand::Check)?,
            "-h" | "--help" => launch.help = true,
            "--version" => launch.version = true,
            // A lone path is the document to open. Anything else beginning with
            // `-` is a typo rather than a file name, and saying so beats opening
            // a window that silently ignored it.
            other if other.starts_with('-') => return Err(format!("unknown argument `{other}`")),
            path if launch.open.is_none() => launch.open = Some(path.into()),
            extra => return Err(format!("only one document can be opened at a time (`{extra}` is the second)")),
        }
    }
    if usize::from(launch.mcp_instance.is_some()) + usize::from(launch.mcp_state_dir.is_some()) + usize::from(launch.mcp_ephemeral) > 1 {
        return Err("give only one of --mcp-instance, --mcp-state-dir, --mcp-ephemeral".into());
    }
    if (launch.mcp_port.is_some() || launch.session_root.is_some()) && !launch.mcp {
        return Err("--mcp-port and --session-root need --mcp".into());
    }
    if launch.associations.is_some() && (launch.mcp || launch.open.is_some() || launch.kicad_library) {
        return Err("--install-file-associations / --uninstall-file-associations do not open a window".into());
    }
    // The importer is a window of its own: it has no document to open and no
    // automation session to be driven as.
    if launch.kicad_library && (launch.mcp || launch.open.is_some()) {
        return Err("--kicad-library opens the KiCad importer, not a document or an MCP session".into());
    }
    if let Some(command) = &launch.plm_command {
        if launch.mcp || launch.open.is_some() || launch.kicad_library || launch.associations.is_some() {
            return Err("--plm-configure / --plm-forget / --plm-show / --plm-check do not open a window".into());
        }
        // Configure writes the URL it names; a second URL would be ignored.
        if matches!(command, PlmCommand::Configure(_)) && launch.plm.url.is_some() {
            return Err("--plm-configure takes the URL itself; drop --plm-url".into());
        }
        if matches!(command, PlmCommand::Forget) && (launch.plm.url.is_some() || launch.plm.token_file.is_some()) {
            return Err("--plm-forget takes no --plm-url or --plm-token-file".into());
        }
    }
    Ok(launch)
}

#[cfg(not(target_arch = "wasm32"))]
fn set_plm_command(launch: &mut Launch, command: PlmCommand) -> Result<(), String> {
    if launch.plm_command.is_some() {
        return Err("give one of --plm-configure, --plm-forget, --plm-show, --plm-check".into());
    }
    launch.plm_command = Some(command);
    Ok(())
}

/// Run a terminal PLM config command against the app's config directory and
/// exit: 0 when it did what it says, 1 when it could not (the sentence is on
/// stderr). No prompt, so an installer script can run it unattended.
#[cfg(not(target_arch = "wasm32"))]
fn run_plm_command(command: &PlmCommand, flags: &brep_app::plm::config::Flags) -> ! {
    use brep_app::plm::config;
    let dir = config::app_config_dir();
    let result = match command {
        PlmCommand::Configure(url) => {
            let token = match &flags.token_file {
                Some(path) => std::fs::read_to_string(path)
                    .map(Some)
                    .map_err(|e| format!("--plm-token-file {}: {e}", path.display())),
                None => Ok(None),
            };
            token
                .and_then(|token| config::write(&dir, url, token.as_deref()))
                .and_then(|()| config::resolve(&dir, &|_| None, &config::Flags::default()))
                .map(|written| config::describe(written.as_ref(), &dir))
                .map(|shown| format!("wrote {}\n{shown}", dir.display()))
        }
        PlmCommand::Forget => config::forget(&dir).map(|removed| {
            if removed.is_empty() {
                format!("no PLM configured in {}: nothing to remove\n", dir.display())
            } else {
                removed.iter().map(|p| format!("removed {}\n", p.display())).collect()
            }
        }),
        PlmCommand::Show => config::resolve(&dir, &|name| std::env::var(name).ok(), flags)
            .map(|resolved| config::describe(resolved.as_ref(), &dir)),
        PlmCommand::Check => config::resolve(&dir, &|name| std::env::var(name).ok(), flags).and_then(|resolved| {
            let config = resolved.ok_or_else(|| config::describe(None, &dir).trim_end().to_string())?;
            let url = config.url.clone();
            brep_app::store::check_native_plm(dir.clone(), config)
                .map(|()| format!("connected to {url}: signed in, and it serves brep-app {}\n", env!("CARGO_PKG_VERSION")))
                .map_err(|e| format!("PLM at {url}: {e}"))
        }),
    };
    match result {
        Ok(text) => {
            print!("{text}");
            std::process::exit(0)
        }
        Err(e) => {
            eprintln!("brep-app: {e}");
            std::process::exit(1)
        }
    }
}

#[cfg(not(target_arch = "wasm32"))]
fn main() -> eframe::Result<()> {
    // Started as a code-mode worker (the app spawning itself for a script):
    // run it, done — no window, no console.
    #[cfg(feature = "mcp")]
    if brep_mcp_core::cad::code::worker_entry() {
        return Ok(());
    }
    #[cfg(windows)]
    if std::env::args_os().len() > 1 {
        windows_console::attach_parent();
    }
    let _ = brep_app::logger::try_init();
    // TypeScript provisioning for run_script: explicit, by a person, never a
    // tool call. The same discovery and probe the MCP server advertises.
    #[cfg(feature = "mcp")]
    match std::env::args().nth(1).as_deref() {
        Some("--provision-typescript") => std::process::exit(match brep_mcp_core::cad::code::provision_typescript() {
            Ok(report) => { println!("{report}"); 0 }
            Err(error) => { eprintln!("brep-app: TypeScript provisioning: {error}"); 1 }
        }),
        Some("--typescript-status") => std::process::exit(match brep_mcp_core::cad::code::typescript_status() {
            Ok((node, tsc)) => { println!("TypeScript {} available: node {} runs {}", brep_mcp_core::cad::code::TSC_VERSION, node.display(), tsc.display()); 0 }
            Err(error) => { eprintln!("brep-app: {}", error.message); 1 }
        }),
        _ => {}
    }
    // The PLM bake worker (plan S10) takes its own flags and opens no window.
    if std::env::args().nth(1).as_deref() == Some("--bake-worker") {
        std::process::exit(brep_app::plm::bake::worker_main(std::env::args().skip(2)));
    }
    let launch = match parse_args(std::env::args().skip(1)) {
        Ok(l) => l,
        Err(e) => {
            eprintln!("brep-app: {e}\n{USAGE}");
            std::process::exit(2);
        }
    };
    if launch.help {
        println!("{USAGE}");
        return Ok(());
    }
    // One line an installer script compares with the server's
    // `min_client_version` (plan S12).
    if launch.version {
        println!("brep-app {}", env!("CARGO_PKG_VERSION"));
        return Ok(());
    }

    // The association commands are terminal: they write the platform's records
    // and exit, opening no window. A step that failed exits non-zero so a
    // packaging script can tell, while still printing what DID land.
    if let Some(install) = launch.associations {
        let (action, steps) = if install {
            ("install", brep_app::file_association::install())
        } else {
            ("uninstall", brep_app::file_association::uninstall())
        };
        print!("{}", brep_app::file_association::report(action, &steps));
        // A missing refresh tool is a warning; only a record that could not
        // be written fails the command.
        let failed = brep_app::file_association::failures(&steps);
        std::process::exit(if failed == 0 { 0 } else { 1 });
    }

    if let Some(command) = &launch.plm_command {
        run_plm_command(command, &launch.plm);
    }

    // The PLM this launch would use (plan D5). No URL from any source is
    // `Ok(None)`, having read nothing but two absent files: the file-based app,
    // built exactly as before the PLM existed. A PLM asked for but unusable as
    // written is said here and on the first frame, and the session starts on
    // the file stores — a PLM never makes the app fail to start.
    let plm = brep_app::plm::config::resolve(
        &brep_app::plm::config::app_config_dir(),
        &|name| std::env::var(name).ok(),
        &launch.plm,
    );
    match &plm {
        Ok(None) => {}
        Ok(Some(config)) => log::info!("PLM configured: {} (from the {})", config.url, config.url_source.describe()),
        Err(e) => eprintln!("brep-app: PLM config: {e}; this session uses the file stores"),
    }

    // The editor can create the embedded server before the HTTP listener is started.
    // Freeze its identity before constructing any window, including plain launches.
    #[cfg(feature = "mcp")]
    if let Err(error) = brep_app::mcp::configure_state(&brep_mcp_core::launch_state::Policy {
        instance: launch.mcp_instance.clone(),
        state_dir: launch.mcp_state_dir.clone(),
        ephemeral: launch.mcp_ephemeral,
    }) {
        eprintln!("brep-app: MCP state: {error}");
        if launch.mcp { std::process::exit(1); }
    }

    #[cfg(feature = "mcp")]
    let mcp = if launch.mcp {
        // Bind first: a port in use is a launch error, not a window without
        // its server. ONE port — the one asked for — where the Info window's
        // button walks a range: a script wants the address it named. The
        // instructions print from the address actually bound; `launch` is the
        // same sequence the button runs later.
        let port = launch.mcp_port.unwrap_or(brep_app::mcp::DEFAULT_PORT);
        let mcp = match brep_app::mcp::launch([port], launch.session_root.clone()) {
            Ok(l) => l,
            Err(e) => {
                eprintln!("brep-app: {e}");
                std::process::exit(1);
            }
        };
        println!("{}", mcp.instructions());
        Some(mcp)
    } else {
        None
    };
    #[cfg(not(feature = "mcp"))]
    if launch.mcp || launch.mcp_instance.is_some() || launch.mcp_state_dir.is_some() || launch.mcp_ephemeral {
        eprintln!("brep-app: this build has no MCP server (built without the `mcp` feature)");
        std::process::exit(1);
    }

    let native_options = eframe::NativeOptions {
        // egui's frame render pass stays single-sample so the viewport blit
        // pipeline (also single-sample) matches; the engine does its own 4x MSAA
        // inside the offscreen render.
        multisampling: 0,
        // Toolbar controls wrap to the available width on native and web.
        ..Default::default()
    };
    // The desktop loop (not `eframe::run_native`): application commands
    // dispatch without waiting for a frame, which a hidden window never gets.
    let result = brep_app::desktop_loop::run(
        "brep-app",
        native_options,
        Box::new(move |cc, waker| {
            brep_app::fonts::install(&cc.egui_ctx);
            let plm_store = |store| brep_app::automation::AppOptions { store: Some(store), ..Default::default() };
            #[allow(unused_mut)]
            let mut app = match plm {
                Ok(None) => brep_app::app::BrepApp::new(cc).map_err(|e| e.to_string())?,
                // Hydrated before the first frame, as the browser hydrates
                // IndexedDB before `WebRunner::start`: every read from here on
                // is synchronous and assumes a complete mirror.
                Ok(Some(config)) => {
                    let ctx = cc.egui_ctx.clone();
                    brep_app::plm::native::set_wake(move || ctx.request_repaint());
                    let store = brep_app::store::boot_native_store(brep_app::plm::config::app_config_dir(), config);
                    brep_app::app::BrepApp::new_with(cc, plm_store(store)).map_err(|e| e.to_string())?
                }
                Err(e) => {
                    let store = brep_app::store::file_store_with_notice(
                        brep_app::plm::config::app_config_dir(),
                        format!("PLM config: {e}"),
                    );
                    brep_app::app::BrepApp::new_with(cc, plm_store(store)).map_err(|e| e.to_string())?
                }
            };
            // The queue's waker is installed before anything can submit: the
            // MCP server below attaches through the queue at once.
            #[cfg(feature = "automation")]
            app.automation().set_waker(waker);
            #[cfg(not(feature = "automation"))]
            let _ = waker;
            // A document named on the command line — or handed over by the file
            // association on a double click — opens before the first frame, so
            // the window never shows the seed document and then swap it.
            if let Some(path) = launch.open.as_deref() {
                app.open_path_from_command_line(path);
            }
            app.start_update_check(&cc.egui_ctx);
            app.start_report_followup(&cc.egui_ctx);
            #[cfg(feature = "mcp")]
            if let Some(launch) = mcp {
                // The app's own diagnostics, not a second reading of the same
                // adapter: the banner a host sees and the Info window a user
                // sees must name the same hardware.
                let adapter = app.diagnostics().adapter_line();
                brep_app::mcp::start(app.automation().clone(), adapter, launch)?;
            }
            Ok(app)
        }),
    )
    .map_err(|e| eframe::Error::AppCreation(e.into()));
    // The UI's own state (settings, layout, the recovery blob) is written
    // behind the frame; land what is still queued before the process ends.
    // The close path already waited for it, so this is normally instant.
    if !brep_app::store::flush_writes(std::time::Duration::from_secs(10)) {
        eprintln!("brep-app: some settings were still being written at exit");
    }
    // An update installed from the notice: start it once this window is gone.
    brep_app::update::relaunch_if_installed();
    result
}

#[cfg(target_arch = "wasm32")]
fn main() {}

/// The parent's console, for a GUI-subsystem executable run from a terminal
/// or a script. kernel32 is always linked, so the three calls are declared
/// here rather than taking a Windows API crate for them.
#[cfg(windows)]
mod windows_console {
    use std::ffi::c_void;

    const ATTACH_PARENT_PROCESS: u32 = u32::MAX; // (DWORD)-1
    const STD_OUTPUT_HANDLE: u32 = -11i32 as u32;
    const STD_ERROR_HANDLE: u32 = -12i32 as u32;
    const GENERIC_READ: u32 = 0x8000_0000;
    const GENERIC_WRITE: u32 = 0x4000_0000;
    const FILE_SHARE_READ: u32 = 1;
    const FILE_SHARE_WRITE: u32 = 2;
    const OPEN_EXISTING: u32 = 3;
    const INVALID_HANDLE_VALUE: *mut c_void = -1isize as *mut c_void;

    #[link(name = "kernel32")]
    extern "system" {
        fn AttachConsole(process: u32) -> i32;
        fn GetStdHandle(which: u32) -> *mut c_void;
        fn SetStdHandle(which: u32, handle: *mut c_void) -> i32;
        fn CreateFileW(
            name: *const u16,
            access: u32,
            share: u32,
            security: *mut c_void,
            disposition: u32,
            flags: u32,
            template: *mut c_void,
        ) -> *mut c_void;
    }

    /// Attach to the console of the process that started this one, if it has
    /// one. Output a caller REDIRECTED (a script capturing `--version`) keeps
    /// its pipe: only a stream with no handle is pointed at the console.
    pub fn attach_parent() {
        // SAFETY: plain Win32 calls with valid arguments; a failure is a
        // return value, and every failure leaves the process as it was.
        unsafe {
            if AttachConsole(ATTACH_PARENT_PROCESS) == 0 {
                return; // started from Explorer, the Start menu, a service
            }
            let name: Vec<u16> = "CONOUT$".encode_utf16().chain(Some(0)).collect();
            for which in [STD_OUTPUT_HANDLE, STD_ERROR_HANDLE] {
                let current = GetStdHandle(which);
                if current.is_null() || current == INVALID_HANDLE_VALUE {
                    let console = CreateFileW(
                        name.as_ptr(),
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        std::ptr::null_mut(),
                        OPEN_EXISTING,
                        0,
                        std::ptr::null_mut(),
                    );
                    if console != INVALID_HANDLE_VALUE {
                        SetStdHandle(which, console);
                    }
                }
            }
        }
    }
}