iocaine 2.5.0

The deadliest poison known to AI
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
111
112
113
114
115
116
117
118

// SPDX-FileCopyrightText: 2025 Gergely Nagy
// SPDX-FileContributor: Gergely Nagy
//
// SPDX-License-Identifier: MIT

#[cfg(all(not(target_env = "musl"), feature = "jemalloc"))]
#[global_allocator]
static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;

use anyhow::Result;
use axum::http::header::{self, HeaderMap, HeaderName};
use clap::Parser;
use std::collections::BTreeMap;
use std::error::Error;

use iocaine::sex_dungeon::{self, Language, LanguageOptions, Request};

#[derive(Debug, Parser)]
#[command(version, about)]
pub struct Args {
    #[arg(short = 's', long)]
    pub script_path: String,
    #[arg(short = 'l', long, value_parser = Self::parse_language, default_value_t = Language::Roto)]
    pub script_language: Language,
    #[arg(short = 'o', long = "language-option", value_parser = Self::parse_key_val::<String, String>)]
    pub language_options: Vec<(String, String)>,

    #[arg(short = 'P', long)]
    pub path: Option<String>,
    #[arg(short = 'A', long, default_value_t = Self::default_user_agent())]
    pub user_agent: String,
    #[arg(short = 'H', long = "header", value_parser = Self::parse_key_val::<String, String>)]
    pub headers: Vec<(String, String)>,
    #[arg(short = 'Q', long = "query", value_parser = Self::parse_key_val::<String, String>)]
    pub query_params: Vec<(String, String)>,
    #[arg(short = 'M', long)]
    pub method: Option<String>,
}

impl Args {
    fn default_user_agent() -> String {
        "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0".to_owned()
    }

    fn parse_key_val<T, U>(
        s: &str,
    ) -> std::result::Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
    where
        T: std::str::FromStr,
        T::Err: Error + Send + Sync + 'static,
        U: std::str::FromStr,
        U::Err: Error + Send + Sync + 'static,
    {
        let pos = s
            .find('=')
            .ok_or_else(|| format!("invalid KEY=value: no `=` found in `{s}`"))?;
        Ok((s[..pos].parse()?, s[pos + 1..].parse()?))
    }

    fn parse_language(
        s: &str,
    ) -> std::result::Result<Language, Box<dyn Error + Send + Sync + 'static>> {
        match s {
            "roto" => Ok(Language::Roto),
            "lua" => Ok(Language::Lua),
            "fennel" => Ok(Language::Fennel),
            l => Err(format!("Unsupported script language: {l}").into()),
        }
    }
}

fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn")),
        )
        .with_writer(std::io::stderr)
        .init();

    let args = Args::parse();

    tracing::info!("Preparing the runtime");

    let mut lang_opts = LanguageOptions::new();
    for (key, value) in args.language_options {
        lang_opts.insert(key, value);
    }

    let handler = sex_dungeon::create(args.script_language, &lang_opts, &args.script_path, None)?;

    let mut headers = HeaderMap::new();
    headers.insert(header::HOST, "example.com".parse()?);
    headers.insert(header::USER_AGENT, args.user_agent.parse()?);

    for (key, value) in args.headers {
        headers.insert(HeaderName::from_bytes(key.as_bytes())?, value.parse()?);
    }

    let mut params = BTreeMap::new();
    for (key, value) in args.query_params {
        params.insert(key, value);
    }

    let request = Request {
        method: args.method.unwrap_or_else(|| "GET".to_owned()),
        path: args.path.unwrap_or_default(),
        headers,
        params,
    };

    tracing::info!("Executing `decide()`");

    let verdict = handler.decide(request);
    println!("{verdict:?}");

    Ok(())
}