winbang 0.1.3

Unix-like shebang support for Windows.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

mod config;
mod dispatch;
mod gui;
mod install;
mod logging;
mod platform;
mod registry;
mod script;
mod verb;

use crate::config::{find_config_path, load_config};
use crate::dispatch::{
    build_command, handle_fallback_dispatch, handle_interactive_dispatch,
};
use crate::platform::is_interactive_parent;
use crate::script::get_script_metadata;
use std::path::{Path, PathBuf};
use std::{env, io, process};

fn main() -> io::Result<()> {
    // Print the current working directory
    #[cfg(debug_assertions)]
    if let Ok(cwd) = env::current_dir() {
        log_debug!(&format!("Current working directory: {:?}", cwd));
    }

    // Ensure Winbang owns every common verb under its own ProgID.
    // Fill-in-the-blanks: never overwrites pre-existing values.
    install::ensure_verbs_registered();

    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <script>", args[0]);
        return Ok(());
    }

    // dispatch-verb subcommand: invoked from Winbang's own registered
    // shell\<verb>\command keys when Windows routes a non-Open verb to us.
    if args[1] == "dispatch-verb" {
        let code = run_dispatch_verb(&args[2..]);
        process::exit(code);
    }

    let config_path =
        find_config_path().unwrap_or_else(|| PathBuf::from("config.toml"));
    let config = load_config(&config_path);

    let script = get_script_metadata(
        &args[1],
        config.file_associations.as_deref().unwrap_or(&[]),
    );

    let extra_args: Option<Vec<String>> = if args.len() > 2 {
        Some(args[2..].to_vec())
    } else {
        None
    };

    log_debug!(&format!("Extra args passed to runtime: {:?}", extra_args));

    if script.association.is_some() {
        let mut command = build_command(&script, extra_args, &config);
        log_debug!("command = {:?}", command);

        // Check if the parent process is a recognized GUI shell
        if is_interactive_parent(&config.gui_shells.clone().unwrap_or_default())
        {
            log_debug!(&format!("Script executed (interactive): {:?}", script));
            handle_interactive_dispatch(&script, &mut command, &config)?;
        } else {
            log_debug!(&format!("Script executed: {:?}", script));
            command.spawn()?.wait()?;
        }
    } else {
        // No interpreter found, fallback to default handler
        log_debug!(&format!(
            "No interpreter found for script: {:?}, using fallback handler",
            script
        ));

        handle_fallback_dispatch(&script, &config)?;
    }

    Ok(())
}

/// Parse and run a `dispatch-verb` invocation. Returns the process exit code.
///
/// Usage shape:
///   <exe-name> dispatch-verb --verb <name> --file <path> [extra-args...]
///
/// Anything after the recognized flag pairs is treated as extra args to pass
/// to the underlying command (substituted into `%*` / `%2`).
fn run_dispatch_verb(args: &[String]) -> i32 {
    let mut verb: Option<String> = None;
    let mut file: Option<String> = None;
    let mut extras: Vec<String> = Vec::new();

    let mut i = 0;
    while i < args.len() {
        match args[i].as_str() {
            "--verb" => {
                if i + 1 >= args.len() {
                    eprintln!("--verb requires a value");
                    return 2;
                }
                verb = Some(args[i + 1].clone());
                i += 2;
            }
            "--file" => {
                if i + 1 >= args.len() {
                    eprintln!("--file requires a value");
                    return 2;
                }
                file = Some(args[i + 1].clone());
                i += 2;
            }
            "--" => {
                extras.extend_from_slice(&args[i + 1..]);
                break;
            }
            other => {
                extras.push(other.to_string());
                i += 1;
            }
        }
    }

    let Some(verb) = verb else {
        eprintln!("dispatch-verb: --verb is required");
        return 2;
    };
    let Some(file) = file else {
        eprintln!("dispatch-verb: --file is required");
        return 2;
    };

    let config_path =
        find_config_path().unwrap_or_else(|| PathBuf::from("config.toml"));
    let config = load_config(&config_path);

    let outcome =
        verb::dispatch_verb(&verb, Path::new(&file), &extras, &config);
    outcome.exit_code()
}